封装特性

• 封装性产生的目：保护某些属性和方法不被外部所看见
• 封装性的实现：为属性和方法进行封装是通过关键字 private 声明的
• 如果某封装属性想被外部所访问，可为该属性设置 set 和 get 方法

匿名对象

• 匿名对象就是没有名字的对象，如果程序中只用一次对象，就可以使用对象的方法
• 匿名对象执行后会被 JC 垃圾回收机制自动回收

class A{
    public void say() { 
    }
}
public class Demo3 {
    public static void main(String[] args) {
        new A().say();//一次性使用
    }
}

继承特性

• 基本概念：扩展父类的功能
• 关键字 ：extends 例如： class 子类 extends 父类

继承的限制

• Java 中只允许单继承，也就是说只能继承一个父类，但是可以实现多个接口
• 子类不能直接访问其父类的私有成员，可以通过 set 与 get 方法来访问

方法覆盖

1. 方法名相同，参数类型或者个数不同
2. 对权限没有要求
3. 发生在一个类中
4. Overloading

方法重写

1. 子类实现了父类的某种方法，其方法名、返回类型、参数完全相同。
2. 被重写的方法的不能拥有比父类更严格的权限
3. 发生在继承中
4. Overriding

super 关键字

• 子类对象不会访问被重写了的父类方法，但是可以在子类重写方法中用 super 关键字来强行调用父类的方法
• 构造方法中默认有 super 方法
• super 关键字不一定在重写中使用，也可以表示那些方法从父类中继承而来，从而在其父类中去寻找该方法的原理。

class A{
    public void say() { 
        System.out.println("A->say");
    }
}

class B extends A{
    public void say() {
        super.say();
        System.out.println("B->say");
    }
}
public class Demo3 {
    public static void main(String[] args) {
        B b = new B();
        b.say();
    }
}

多态特性

向上转型与向下转型

• 向上转型：创建子类对象却分配给父类实例
  eg: 父类 父类实例 = new 子类（）；
• 向下转型：必须先向上转型之后才能使用向下转型
  eg: 子类 子类实例 = （子类）父类实例；

什么是多态

• 顾名思义就是多种状态，在一定程度上让代码更具有灵活性。
• 所谓多态，就是指一个引用（类型）在不同情况下的多种状态；也可以理解为，多态是通过指向父类的指针，来调用不同子类中实现的方法。
• 理解了向上转型与向下转型之后，再讨论多态就好理解了，先看下面的代码：

public class Demo3 {

    public static void main(String[] args) {// TODO Auto-generated method stub
        //向上转型
        Animal an = new Dog();
        an.say();  //通过指向父类的指针去调用子类已实现的方法
        an.tell1(); 
    
        //向下转型
        Cat cat = (Cat) an;
        cat.say();
        cat.tell1;
    }

}

class Animal{
    public void say(){
        System.out.println("我是动物");
    }
    public void tell1(){
        System.out.println("动物在说话");
    }
}

class Dog extends Animal{
    //覆盖父类方法
    public void say() {
        System.out.println("我是狗");
    }
    public void tell2(){
        System.out.println("狗在发声");
    }
}

class Cat extends Animal{
    public void say() {
        System.out.println("我是猫");
    }
}

其输出为：

我是狗
动物在说话
我是猫
动物在说话

具体应用分析

public class Demo2 {

    public static void main(String[] args) {
        Manager manager = new Manager();
        // new 子类，通过指向父类的指针来调用子类中实现的方法
        manager.feed(new Dog(), new Bone("骨头"));
        manager.feed(new Cat(), new Fish("鱼"));     
        manager.feed(new smallDog(), new smallBone("小骨头"));
    }

}
//管理员
class Manager{
    //声明一个一个方法，其参数都是父类的引用，在main函数调用时传的值为具体的子类
    public void feed(Animal an,Food food){                   
        an.eat(food);
        food.showFood(food);
    }
}
//食物类
class Food{
    //构造方法
    public Food(String name) {
        this.name = name;
    }
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void showFood(Food food){
        System.out.println("我是"+ food.getName());
    }
}
//鱼类
class Fish extends Food{
    //继承带有构造方法的父类必须实现其够着方法
    public Fish(String name) {
        super(name);
    }

    public void showFood(Food food) {
        System.out.println("我是" + food.getName());
    }
}
//骨头类
class Bone extends Food{
    public Bone(String name) {
        super(name);
    }

    public void showFood(Food food) {
        System.out.println("我是" + food.getName());
    }
}
//孙子骨头类
class smallBone extends Bone{

    public smallBone(String name) {
        super(name);
    }
    public void showFood(Food food) {
        System.out.println("我是" + food.getName());
    }

}
//动物类
class Animal{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public void eat(Food food) {
        System.out.println("我吃" + food.getName());
    }
}
//狗类
class Dog extends Animal{
    public void eat(Food food){
        System.out.println("狗吃" + food.getName());
    }
}
//猫类
class Cat extends Animal{
    public void eat(Food food) {
        System.out.println("猫吃" + food.getName());
    }
}
//孙子狗类
class smallDog extends Dog{
    
    public void eat(Food food){
        System.out.println("小狗狗吃" + food.getName() );
    }
}

其输出为：

够吃骨头
我是骨头
猫吃鱼
我是鱼
小狗狗吃骨头
我是小骨头

instanceof 关键字

• 可以通过 instanceof 关键字判断一个对象到底是不是一个类的实例

public class Demo3 {

    public static void main(String[] args) {// TODO Auto-generated method stub
        //向上转型
         A a = new A();
         System.out.println(a instanceof A);//输出true
         System.out.println(a instanceof B);//输出false
         A a1 = new B();
         System.out.println(a1 instanceof A);//输出true
         System.out.println(a1 instanceof B);//输出true
    }

}

class A{
}
class B extends A{}

• 通过上述代码例子，可以发现其父类的对象不会是其子类的实例，但是其子类的对象可以是父列的实例