静态成员变量#

成员变量按照有无static修饰，分为两种：

• 静态变量（类变量）：有static修饰，属于类，在计算机中只有一份，会被类的全部对象共享。
• 实例变量（对象的变量）：无static修饰，属于每个对象的。

访问方式：

1
类名.静态变量（推荐）
2
对象.静态变量（不推荐）

1
对象.实例变量

修改方式：注意下面两种都可以修改静态变量

1
类名.静态变量 = 新值
2
对象.静态变量 = 新值（不推荐）

静态变量的应用场景：

• 如果某个数据只需要一份，且希望能够被共享（访问、修改），则该数据可以定义为静态变量。

例如：系统启动后，要求用户类可以记住自己创建了多少个用户对象了。

1
public class User {
2
    public static int count = 0;
3

4
    //构造器
5
    public User() {
6
        // User.count++;
7
        count++; // 同一个类中访问静态变量可以省略类名不写
8
    }
9
}

静态方法#

成员方法的分类：

• 静态方法：有static修饰的成员方法，属于类。
• 实例方法：无static修饰的成员方法，属于对象。

访问方式：

1
类名.静态方法（推荐）
2
对象.静态方法（不推荐）

1
对象.实例方法

规范：

• 如果这个方法只是为了做一个功能且不需要直接访问对象的数据，这个方法可以直接定义为静态方法。
• 如果这个方法是对象的行为，需要访问对象的数据，这个方法必须定义成实例方法。

静态方法的应用场景：

• 做工具类。

工具类是什么：

• 工具类中的方法都是一些静态方法，每个方法用来完成一个功能，以便给开发人员直接使用。

工具类好处：

• 提高了代码复用；调用方便，提高了开发效率。
• 每次不用实例化对象，节约内存。

多学一招：

• 工具类没有创建对象的需求，建议将工具类的构造器进行私有（private）。

静态/实例方法访问的注意事项#

• 静态方法中可以直接访问静态成员（变量/方法），不可以直接访问实例成员（变量/方法）。
• 实例方法中既可以直接访问静态成员（变量/方法），也可以直接访问实例成员（变量/方法）。
• 实例方法中可以出现this关键字，静态方法中不可以出现this关键字（因为this代表的只能是当前对象）。

认识继承#

提高代码的重用性，减少一些重复代码的书写。

Java中提供了一个关键字extends，用这个关键字，可以让一个类和另一个类建立起父子关系。

1
public class B extends A {
2
    ...
3
}

• 子类能继承父类的非私有成员（变量/方法），父类的私有变量可以通过父类的非私有getter/setter方法访问。
• 子类的对象是由子类、父类共同创建完成的

权限修饰符#

权限修饰符就是用来限制类中的成员（成员变量、成员方法、构造器）能够被访问的范围。

• private：只能本类中
• 缺省：本类、同一包中的类
• protected：本类、同一包中的类、子孙类中
• public：任意位置

范围：private < 缺省 < protected < public

继承的特点#

• 单继承：Java是单继承模式，一个类只能继承一个直接父类。

• 多层继承：Java不支持多继承，但支持多层继承。

• 祖宗类：Java中所有的类都是Object类的子类。

• 就近原则：有限访问自己类中，自己类中没有的才会访问父类。

  如果子父类中出现了重名的成员，会优先使用子类的，如果此时一定要在子类中使用父类的怎么办：supper关键字

  1
  super.父类成员变量/方法

方法重写#

当子类觉得父类中的某个方法不好用，或者无法满足自己的需求时，子类可以重写一个方法名称、参数列表一样的方法，去覆盖父类的这个方法，这就是方法重写。

注意：

• 建议在子类重写的方法上方使用@Override注解，它可以指定Java编译器检查我们方法重写的格式是否正确，代码可读性也会更好。
• 子类重写父类方法时，访问权限必须必须大于等于父类方法的权限。
• 重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
• 私有方法、静态方法不能被重写，如果重写会报错。

常见场景：

• 子类重写Object类的toString()方法，以便返回对象的内容。

  直接打印对象，默认会调用Object类的toString方法（可以省略不写调用toString的代码），返回的是对象的地址信息。所以要重写。

  1
  @Override
  2
  public String toString() {
  3
      return ...
  4
  }

子类构造器的特点#

子类的全部构造器，都会先调用父类的构造器，再执行自己的。

• 默认子类全部构造器的第一行代码都是super();（可以省略不写），会调用父类的无参构造器。

• 如果父类没有无参构造器/无参构造器私有，必须用super指定调用父类的有参构造器：

1
class Zi extends Fu {
2
    public Zi() {
3
        super(6);
4
        ...
5
    }
6
}
7

8
class Fu {
9
    private Fu() { ... }
10
    public Fu(int a) { ... }
11
}

为什么一定要先调用父类的构造器：

• 子类构造器可以通过调用父类构造器，把对象中包含父类这部分的数据先初始化赋值。
• 再回来把对象里包含子类这部分的数据也进行初始化赋值。

构造器中this调用兄弟构造器#

注意：super和this(...)必须写在构造器第一行，并且两者不能同时出现。

例如：

1
public class Student {
2
    private String name;
3
    private String schoolName;
4

5
    public Student(String name) {
6
        // this调用兄弟构造器
7
        this(name, "清华大学");
8
    }
9

10
    public Student(String name, String schoolName) {
11
        this.name = name;
12
        this.schoolName = schoolName;
13
    }
14
}

认识多态#

多态是在继承/实现情况下的一种现象，表现为：对象多态（人分为男人女人）、行为多态（猫喵喵叫，狗汪汪叫）。

多态的好处#

• 在多态形势下，对象是解耦合的，更便于扩展和维护。

  这个对象不想用了，可以直接换成另一个（一家公司提供的业务不好，可以无缝换到另一家）:

  1
  Animal a = new Dog();
  2
  // 当换成new Cat后，下面的代码（业务）不用动
  3
  a.voice();

• 定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利。

  1
  public static void main(String[] args) {
  2
      Dog d = new Dog();
  3
      animal_voice(d);
  4
  
  5
      Cat c = new Cat();
  6
      animal_voice(c); // 不给调用
  7
  }
  8
  public static void animal_voice(Dog d) {
  9
      d.voice();
  10
  } // 不便利

  而下面的就便利：

  1
  public static void animal_voice(Animal a) {
  2
      a.voice();
  3
  }

多态下的问题和类型转换#

多态下的问题：多态下不能使用子类的独有功能。

1
public static void main(String[] args) {
2
    Dog d = new Dog();
3
    animal_voice(d);
4

5
}
6
public static void animal_voice(Animal a) {
7
    a.voice();
8
    a.eat_bone(); // 狗特有方法 吃骨头
9
}

多态下的类型转换：

• 自动类型转换：父类 变量名 = new 子类();
• 强制类型转换：子类 变量名 = (子类) 父类变量;

1
Animal a = new Dog();
2
Dog d = (Dog) a; // 强制类型转换
3
d.eat_bone();

强制类型转换的一个注意事项：

• 存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。
• 运行时，如果发现对象的真实类型于强转后的类型不同，就会报类型转换异常（ClassCastException）错误。

1
Animal a = new Dog();
2
Cat c = (Cat) a; // 报错，狗不能转为猫

Java 建议强转前，先判断对象的真实类型，再进行强转。改为：

1
Animal a = new Dog();
2
if (a.isinstanceof(Cat)) {
3
    Cat c = (Cat) a;
4
    ...;
5
}
6
else if (a.isinstanceof(Dog)) {
7
    Dog d = (Dog) a;
8
    ...;
9
}