JAVA学习笔记05——面向对象进阶

1.面向对象三大特征——继承

class Person {
    String name;
    int height;
    public void rest(){
    }  
}
class Student extends Person {
    String major; //专业
    public Student(String name,int height,String major) {
        //天然拥有父类的属性
        this.name = name;
        this.height = height;
        this.major = major;
    }
}

子类（Student）继承了父类（Person）的属性和方法。

sinstanceof运算符：左边是对象，右边是类，当左面对象是右面类或子类所创建对象时，返回true；否则，返回false。如：p instanceof Person。

（1）JAVA中类没有多继承，接口有多继承。

（2）子类继承了父类的全部属性和方法，但是不一定可以直接访问（父类的私有属性和方法）。

（3）子类可以重写父类的方法。

2.Object类

Object类是所有JAVA类的根基类。JAVA中所有的对象都拥有Object类的属性和方法。

（1）toString方法：默认会返回“类名+@+16进制的hashcode”。直接打印对象名调用toString方法：System.out.println(p)。可以重写该方法。

（2）==和equals方法。==：如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。equals：默认就是比较两个对象的hashcode。可以重写该方法。JDK中的一些类重写了equals的方法。

3.Super关键字

super关键字：super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。如：父类Person子类Man，子类（Man）中重写了父类（Person）的cry方法，则在子类中使用super.cry可以调用父类的cry方法。

4.继承树追溯

1.属性/方法：从当前类依次追溯每个父类。

2.构造方法：构造方法第一句总是：super(…)来调用父类对应的构造方法。所以，流程就是：先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。

5.面向对象三大特征——封装

JAVA使用“访问控制符”来控制那些细节需要封装，那些细节需要暴露。分别为private、default、protected、public。

 6.面向对象三大特征——多态

多态最为多见的一种用法，即父类引用做方法的形参，实参可以是任意的子类对象，可以通过不同的子类对象实现不同的行为方式。即：Animal a1 = new Dog();

多态调用重写的方法时调用了子类的方法，多态无法调用子类独有的功能。

想要调用子类的功能需要向下转型，即：Dog dog = (Dog)a1;（注意向下转型时需要转换为真实的子类类型）

1. 多态是方法的多态，不是属性的多态(多态与属性无关)。

2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。

3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

class Animal {
    public void shout() {
        System.out.println("叫了一声！");
    }
}
class Dog extends Animal {
    public void shout() {
        System.out.println("旺旺旺！");
    }
    public void seeDoor() {
        System.out.println("看门中....");
    }
}
class Cat extends Animal {
    public void shout() {
        System.out.println("喵喵喵喵！");
    }
}
public class TestPolym {
    public static void main(String[] args) {
        Animal a1 = new Cat(); // 向上可以自动转型
        //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。
        animalCry(a1);
        Animal a2 = new Dog();
        animalCry(a2);//a2为编译类型，Dog对象才是运行时类型。
        // a2.seeDoor 不能运行
        //编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。
        // 否则通不过编译器的检查。
        Dog dog = (Dog)a2;//向下需要强制类型转换
        dog.seeDoor();
    }
 
    // 有了多态，只需要让增加的这个类继承Animal类就可以了。
    static void animalCry(Animal a) {
        a.shout();
    }

}

7.final关键字

1.修饰变量：被他修饰的变量不可改。

2.修饰方法：该方法不可被子类重写。但是可以被重载!

3. 修饰类: 修饰的类不能被继承。

8.抽象方法和抽象类

1.抽象方法：使用abstract修饰的方法，没有方法体，只有声明。

2.抽象类：包含抽象方法的类就是抽象类。

3.抽象类只能被继承，不能new实例化。

4.抽象类的抽象方法必须被子类实现。

9.接口interface

接口中的所有方法都是抽象方法。

接口定义：1.访问修饰符：只能是public或默认。2.类可以继承多个接口。3.接口中的属性总是常量，总是：public static final 修饰。 5. 方法：接口中的方法只能是：public abstract。 

接口的使用：1.子类通过implements来实现。2.一个类实现了接口就要实现接口中的所有方法。3.节口可以多继承。

10.内部类

内部类可以使用public、default、protected 、private以及static修饰。而外部顶级类(我们以前接触的类)只能使用public和default修饰。

class Outer {
    private int age = 10;
    class Inner {
        int age = 20;
        public void show() {
            int age = 30;
            System.out.println("内部类方法里的局部变量age:" + age);// 30
            System.out.println("内部类的成员变量age:" + this.age);// 20
            System.out.println("外部类的成员变量age:" + Outer.this.age);// 10
        }
    }
}

成员变量访问：1. 内部类里方法的局部变量：变量名。2. 内部类属性：this.变量名。3. 外部类属性：外部类名.this.变量名。

内部类的访问：1. 外部类中定义内部类：new Inner() 2. 外部类以外的地方使用非静态内部类：Outer.Inner  varname = new Outer().new Inner()。（静态内部类：Outer.Inner  varname = new Outer.Inner()）

11.String类基础

12.模板方法和回调原则

暂时看不懂