Java基础学习（二）

包

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

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

访问修饰符

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

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

继承

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

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

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

public class Exercise01 {
    public static void main(String[] args) {
        B b = new B();
        /*输出
        A()
		B(String name)
		B()*/
    }
}
class A {
    A() {
        System.out.println("A()");
    }
    A(String name) {
        System.out.println("A(String name)");
    }

}

class B extends A{
    B(){
        this("abc");
        System.out.println("B()");
    }
    B(String name) {
        System.out.println("B(String name)");
    }
}

多态

向上转型

1. 一个多态的编译类型和运行类型可以不一致

Animal animal  = new Dog();//animal 编译类型是Animal，运行类型Dog.

2. 编译类型在定义对象时，就确定了，不能改变。
3. 运行类型可以改变

animal = new Cat(); //animal运行类型变成了Cat, 编译类型仍然是Animal.

4. 可以调用编译类型中所有成员（需要遵守访问权限），不能调用运行类型中特有的成员。
   Animal 中有eat(),sleep(), Cat 中有catch(), animal = new Cat();后，只能调用eat(),sleep(),不能调用catch()。
5. 最终运行效果看运行类型的具体实现，如Cat对eat()重写，animal.eat()后，具体效果是Cat对eat()的实现。
6. 属性啊没有重写之说！ 属性的值看编译类型

public class PolyDetail01 {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.count);  //1
        B b = new B();
        System.out.println(b.count);  //2

    }
}
class A {
    int count = 1;
}
class  B extends  A {
    int count = 2;
}

向下转型

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

instanceOf比较符

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

public class PolyDetail02 {
    public static void main(String[] args) {
        BB bb = new BB();
        System.out.println(bb instanceof BB); //true
        System.out.println(bb instanceof AA); //true
        
        AA aa = new BB();
        System.out.println(aa instanceof BB); //true
        System.out.println(aa instanceof AA); //true

    }
}

class AA{}
class BB extends AA{}

动态绑定机制

/*
java的动态绑定机制
1.当调用对象的方法的时候，该方法会和该对象的内存地址/运行类型绑定
2.当调用对象属性时，没有动态绑定机制，哪里声明，哪里使用
 */
public class DynamicBinding {
    public static void main(String[] args) {
        A a = new B();
        System.out.println(a.sum()); //40   注释B中的sum(),结果为30
        System.out.println(a.sum1());  //30  注释B中的sum1(),结果为20

    }
}

class A {
    public int i = 10;

    public int getI() {
        return i;
    }

    public int sum() {
        return getI() + 10;
    }

    public int sum1() {
        return  i + 10;
    }

}
class B extends  A {
    public int i = 20;

    @Override
    public int getI() {
        return i;
    }

    @Override
    public int sum() {
        return i + 20;
    }

    @Override
    public int sum1() {
        return i + 10;
    }
}

Object 方法

• equals()
  Object 的equals()方法就是比较地址是否相同，子类中如Integar,String重写了方法，用于比较内容是否相等。

• hashCode()
  1.提高具有哈希结构的容器的效率
  2.两个引用，如果指向的是同一个对象，则哈希值肯定是一样的
  3.两个引用，如果指向的是不同对象，则哈希值是不一样的
  4.哈希值主要根据地址号来的，不能完全等价于地址

• toString
  没重写的情况下是输出引用的16进制哈希码
  重写后一般输出类的属性

• finalize
  当对象被回收时，系统自动调用该对象的finalize()方法。