包

实质上是创建不同的文件夹来保存类文件

  1. 区分相同名字的类
  2. 当类很多时，可以很好管理类
  3. 控制访问范围

访问修饰符

Public:对外公开。
Protected:对子类和同一个包中的类公开。
默认：对同一个包的类公开。
private: 只有类本身可以访问。

方法只有public 和默认可以修饰。

QQ截图20220113220942.png

继承

  1. 子类继承了所有的属性和方法，但是私有属性和方法不能在子类直接访问，要通过公共方法去访问
  2. 子类必须调用父类的构造器，完成父类的初始化，先调用父类的，再调用子类
  3. 当创建子类对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用 super 去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不通过。

访问子类的属性的步骤：
（1）首先看子类是否有该属性
（2）如果子类有该属性并可以访问，则返回信息（不可以访问会报错）
（3） 如果子类没有，就看父类有没有这个属性

有this就不会默认调用super();

  3. public class Exercise01 {
  4.     public static void main(String[] args) {
  5.         B b = new B();
  6.         /*输出
  7.         A()
  8.         B(String name)
  9.         B()*/
  10.     }
  11. }
  12. class A {
  13.     A() {
  14.         System.out.println("A()");
  15.     }
  16.     A(String name) {
  17.         System.out.println("A(String name)");
  18.     }
  20. }
  22. class B extends A{
  23.     B(){
  24.         this("abc");
  25.         System.out.println("B()");
  26.     }
  27.     B(String name) {
  28.         System.out.println("B(String name)");
  29.     }
  30. }

多态

向上转型

  1. 一个多态的编译类型和运行类型可以不一致
  1. Animal animal  = new Dog();//animal 编译类型是Animal，运行类型Dog.
  1. 编译类型在定义对象时，就确定了，不能改变。
  2. 运行类型可以改变
  1. animal = new Cat(); //animal运行类型变成了Cat, 编译类型仍然是Animal.
  1. 可以调用编译类型中所有成员（需要遵守访问权限），不能调用运行类型中特有的成员。
    Animal 中有eat(),sleep(), Cat 中有catch(), animal = new Cat();后，只能调用eat(),sleep(),不能调用catch()。
  2. 最终运行效果看运行类型的具体实现，如Cat对eat()重写，animal.eat()后，具体效果是Cat对eat()的实现。
  3. 属性啊没有重写之说！ 属性的值看编译类型
  1. public class PolyDetail01 {
  2.     public static void main(String[] args) {
  3.         A a = new B();
  4.         System.out.println(a.count);  //1
  5.         B b = new B();
  6.         System.out.println(b.count);  //2
  8.     }
  9. }
  10. class A {
  11.     int count = 1;
  12. }
  13. class  B extends  A {
  14.     int count = 2;
  15. }

向下转型

  2. Animal animal = new Cat();//不能调用cat类中特有的方法
  3. Cat cat = (Cat)animal; // 向下转型后能调用cat中特有的方法
  4. //Dog dog = (Dog)animal; 这是错误的

instanceOf比较符

用于判断的运行类型是否为XX类型或XX类型的子类型

  1. public class PolyDetail02 {
  2.     public static void main(String[] args) {
  3.         BB bb = new BB();
  4.         System.out.println(bb instanceof BB); //true
  5.         System.out.println(bb instanceof AA); //true
  7.         AA aa = new BB();
  8.         System.out.println(aa instanceof BB); //true
  9.         System.out.println(aa instanceof AA); //true
  11.     }
  12. }
  14. class AA{}
  15. class BB extends AA{}

动态绑定机制

  2. /*
  3. java的动态绑定机制
  4. 1.当调用对象的方法的时候，该方法会和该对象的内存地址/运行类型绑定
  5. 2.当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用
  6.  */
  7. public class DynamicBinding {
  8.     public static void main(String[] args) {
  9.         A a = new B();
  10.         System.out.println(a.sum()); //40   注释B中的sum(),结果为30
  11.         System.out.println(a.sum1());  //30  注释B中的sum1(),结果为20
  13.     }
  14. }
  16. class A {
  17.     public int i = 10;
  19.     public int getI() {
  20.         return i;
  21.     }
  23.     public int sum() {
  24.         return getI() + 10;
  25.     }
  27.     public int sum1() {
  28.         return  i + 10;
  29.     }
  31. }
  32. class B extends  A {
  33.     public int i = 20;
  35.     @Override
  36.     public int getI() {
  37.         return i;
  38.     }
  40.     @Override
  41.     public int sum() {
  42.         return i + 20;
  43.     }
  45.     @Override
  46.     public int sum1() {
  47.         return i + 10;
  48.     }
  49. }

Object 方法

  • equals()
    Object 的equals()方法就是比较地址是否相同，子类中如Integar,String重写了方法，用于比较内容是否相等。
  • hashCode()
    1.提高具有哈希结构的容器的效率
    2.两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
    3.两个引用，如果指向的是不同对象，则哈希值是不一样的
    4.哈希值主要根据地址号来的，不能完全等价于地址
  • toString
    没重写的情况下是输出引用的16进制哈希码
    重写后一般输出类的属性
  • finalize
    当对象被回收时，系统自动调用该对象的finalize()方法。