Java第二模块

• 创建类的好处
  • 可以创建无数个对象
  • 可以有不同数据类型的属性
  • 可以有不同的方法

public class Card{
    //属性，又叫成员变量：类里面，方法外面定义，并且不加static，创建对象后才会分配空间，而且每个对象都有自己不同的成员变量
    double money;//定义完后有默认值
    String cid;
    String pwd;
    void give(){//类函数，又叫成员方法，不加static，创建对象以后才能使用
        System.out.println("给你卡片");
    }
}//卡片类
//创建卡片对象
Card c=new Card();//Card是构造函数，每个类里面有个默认的，不用写
c.money=10000;
c.cid="111111111111";
c.pwd="123456";

• 构造函数

  //构造函数的特点：没有返回类型，名字与类名相同
  public Person(){
      System.out.println("我是人");//覆盖默认的构造函数
  }//一般无参默认构造函数要写上
  //利用构造函数赋值
  public Person(String name,int age,char sex,float h){
      this.name=name;//this指的是当前对象，谁调用就是谁
      this.age=age;//this在类内部使用
      this.sex=sex;
      this.h=h;
  }
  //可以有多个构造函数，但是参数列表得不同，也就是方法重载（与前面的控制符无关）
  //重载：方法名相同，参数列表不同，参数个数不同或者参数类型不同
  //构造函数是在new后面调用，不能用对象来调用
  public class Rectangle{
      Point p1;
      Point p2;//对象里面包含对象
      public Rectangle(Point p1, Point p2){
          this.p1 = p1;
          this.p2 = p2;
      }
      void area(Point p1, Point p2) {
          p1.x++;//可以修改其他对象的成员变量，但是private的不能直接修改
                  //private想要自减就得在类内部创建自减函数
          return (p1.x-p2.x)*(p1.y-p2.y);
  }
  }
  public class Point{
      double x;
      double y;
      public Point(double x, double y){
          this.x = x;
          this.y = y;
      }
  }
  Rectangle rect=new Rectangle();//创建Rectangle的同时创建了Point
  rect.p1.x=1;//赋值方法1
  rect.p2.x=2;
  rect.p1.y=1;
  rect.p2.y=2;//多次.出来
  
  rect.p1=new Point(1,1);//构造函数用在new后面
  rect.p2=new Point(2,2);//法二
  
  Rectangle rect2=new Rectangle(new Point(1,1),new Point(2,2));//法三
  
  System.out.println(rect2.area(p1,p2));//对象之间的交互靠传递对象参数的函数

• 封装

  //为了不让外部赋值出现错误，所以赋值得用get set方法先进行判断
  person.age=-100;//这是错误的
  //用private放在类变量前面，则该变量出了类就无法赋值了，或者任何修改操作了，除非用类内部专门进行修改的函数
  private int age;
  
  public void setAge(int age){
      if(age>=0)
          this.age=age;
      else
          System.out.println("年龄不合法");
  }
  //一般成员变量都是私有的
  public int getAge(){
      return this.age;//有set一般就有get，除非是只读或者只写
  }
  //在eclipse里导航栏的source里面可以快捷添加getter和setter方法
  
  //方法也能私有，在类外部就用不了了，一般用于为类内部的其他方法所调用，成为某个方法的组件

• 静态变量,静态方法,静态块

public class Person {
private String name;
static int count=0;//添加了static则所有对象共用一个count，一个对象修改count，则全部对象count都被修改
static void test(){
    System.out.println(name);//会报错，因为静态方法不能访问成员变量（可以访问静态变量），因为静态方法在new之前就有了，而成员变量是在new之后才有值的
}
static void print(){
    System.out.println("总共打印了"+count+"个对象");
}
}
Person.count;//可以用对象名访问，但最好用类名访问
Person.print();
//系统自带的函数中，如果不用new的就是静态方法（带s的）

//静态块
static{
    System.out.println("类加载完毕了");//用于初始化操作，代码加载完毕后，是最先开始的自动运行的
}

• 小知识点
  新建包，就相当于建了文件夹，不同包里面的相同的文件名就不会冲突
  如果命名为：aaa.bbb.ccc就会建三层文件夹

• 继承

  public class Dog extends Animal {//子类继承父类会拥有父类所有非私有的属性和方法
  
  }
  //如果要利用父类的私有属性对子类属性进行赋值，可以用
  this.setName(name);//这样，因为无法直接访问父类私有属性
  //显然父类不能访问子类的
  //一个子类不能继承多个父类
  //但是父类（子类）可以被多个子类继承
  Dog d=new Dog();//在创建子类对象时，会先调用父类的无参构造函数，创造一个父类的匿名对象
  //然后子类才能使用父类的非私有属性和方法
  //如果要调用父类的有参构造函数来对子类属性赋值可以用super
  public Dog(name)
  {
      super(name);
  }

• 继承中的重写问题

  //父类中有一个方法，子类方法的方法名相同，参数列表也相同，只是内容不同，又叫方法覆盖
  //如果方法名相同但是参数列表不同，那就是方法重载
  //重写的时候如果还是需要父类一部分已经写好的方法，也可以用super
  
  public class Role{
      private String name;
      public void print() {
          System.out.println("姓名："+this.name);
  }
  }
  
  public class Magicer extends Role{
      private int level;
      public void print(){
          super.print();//调用父类方法
          System.out.println("等级："+this.level)
      }
  }
  //父类还可以起到规范方法名的作用

• 多态

  //因为方法重载需要写很多次，所以用父类来作为接收的东西
  public int attack(Role r){//子类方法用父类来接收就可以接收所有子类，不用子类一个个重载
      System.out.println("人物等级："+this.level)
      return hurt;
  }
  Role role =new Magicer();//把role称为上转型变量，可以访问从父类继承的属性和方法，但不能访问子类的；如果父类属性和方法被重写了，则只能访问子类重写的；可以转化为子类对象
  Magicer magicer =(Magicer) role;//强制转换类型
  //上转型变量除了能用于接收参数以外，也能用来接收对象数组
  Animal[] animal=new Animal[10];
  for(int i=0;i<animal.length;i++){
      Random r=new Random();
      switch(r.nextInt(4)+1){
          case 1:animal[i]=new Cat();break;
          case 2:animal[i]=new Dog();break;
          case 3:animal[i]=new Cow();break;
          case 4:animal[i]=new Sheep();break;
  
      }
  }
  for(int i=0;i<=animal.length;i++)
  {
      animal[i].speak();//使用重写后的方法
  }

• 包和访问控制符

  //新建一个package,就能在不同package里面创建同名的类
  //public 不同包以及本包都能访问，通过导包 import 包名.类名，只有不同包才要导入
  //如果不加public 或者说不加访问控制符，那它就是默认的default，只能在本包里访问
  //对于类来说，只能有public 和 default两种访问控制符
  
  //对于属性和方法来说有四种访问控制符
  //private 本类内部
  //default 本类中，本包中
  //protected 本类中，同一个包中，不同包中的子类里面（父类在不同包里面的继承）
  //public 都可以

• 面向对象三大特征
  封装、继承、多态

• 抽象类
  如果一个类中有抽象方法，那么类就要定义为抽象类

  //在class前面加上abstract
  public abstract class Animal{
      void abstract sing();
  }
  //子类必须重写抽象方法，override
  //用于子类命名规范并且符合实际
  //抽象类不能new对象，实例化
  //重写后的访问控制符的访问不能比重写前的小

• 接口

  //虽然抽象类可以让子类方法能够统一命名，但是有些方法不是所有子类都有的，不能直接用抽象类，比如不是所有动物都能抓老鼠，这时候就要用接口
  
  //新建一个接口类
  public interface CatchMouth(){
      public void catchMouth();//默认是抽象的，公共的，所以public也可以省去
      int a=1;//默认是public static final 不可修改的全局变量
  }
  //让相应的对象实现接口
  public class Cat extends Animal implements CatchMouth{//这下必须重写（方法名相同，参数列表相同）
  
  }
  //接口类实现多态效果
  CatchMouth c=new Cat();
  CatchMouth d=new Dog();
  c.catchMouth();
  d.catchMouth();//接口引用可以指向实现类对象
  
  //接口也可以作为参数实现多态
  public class Person{
      void Catch(CatchMouth c){
          c.catchMouth;
      }
  }
  Person p=new Person();
  p.Catch(new Cat());
  p.Catch(new Dog());
  //接口可以实现多继承的问题
  //一个类可以实现多个接口，用逗号隔开

• final 关键字

  final int a=3;//该变量值不能修改
  final void test(){//子类不能重写该方法（方法名相同参数列表相同）
  
  }
  final public A{//final修饰类，则该类不能被继承
  
  }