Java学习day012（面向对象三大特征补充）

多态

同一个对象在不同时刻表现出来的不同状态

举 :猫
猫是猫: 猫 cat = new 猫();
猫是动物: 动物 cat = new 猫();
猫在不同时刻体现出来了不同状态，这个就是多态

多态的前提和体现
1.有继承/实现关系
2.有方法重写
3.有父类引用指向子类对象

For example

定义三个类
Animal
Cat
AnimalDemo	// 测试类

package com.study_01;
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
-----
package com.study_01;
// 多态前提第一步  继承关系
public class cat extends Animal{
    // 第二步  eat()方法重写
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
-----
package com.study_01;
public class AnimalDemo {
    public static void main(String[] args) {
        // 第三步 有父类引用指向子类对象
        Animal a = new cat();
        a.eat(); // 猫吃鱼
    }
}

---

多态的成员访问的特点

成员变量：编译看左边，执行看左边
成员方法：编译看左边，执行看右边

Question:为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写，而成员变量没有

For example

定义三个类
Animal
Cat
AnimalDemo	// 测试类

package com.study_02;

public class Animal {
	// 父类的成员变量
    public int age = 40;

    public void eat() {
        System.out.println("动物吃东西");
    }
}
-----
package com.study_02;
// 有继承
public class Cat extends Animal{

    public int age = 20;
    public int weight = 10;
	// 有方法重写
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
-----
package com.study_02;

public class AnimalDemo {

    public static void main(String[] args) {
        // 有父类引用指向子类对象
        Animal a  = new Cat();

        System.out.println(a.age); // 40
        // 成员变量  编译看左边,运行看左边
        // 最终呈现的其实是动物类里面age变量的值
//        System.out.println(a.weight); // 编译看左边,动物类里面并没有weight变量,所以报错

        a.eat(); // 猫吃鱼
        // 成员方法  编译看左边,运行看右边
//        a.playGame;
		// 编译看左边,动物里面没有playGame()方法,该方法时Cat类特有的
    }
}

多态的好处和弊端

好处：提高了程序的扩展性

具体体现：定义方法的时候，使用父类类型作为参数，将来在使用的时候，使用具体的子类型参与操作

弊端：不能使用子类的特有功能

For example

定义五个类
Animal
Cat
Dog
AnimalOperateor  // 操作类
AnimalDemo	// 测试类

package com.study_03;
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
-----
package com.study_03;
// 继承父类
public class Cat extends Animal {
	// 重写父类方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
-----
package com.study_03;
public class Dog extends Animal{
	// 重写父类方法
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void lookDoor() {
        System.out.println("狗看门");
    }
}
------
package com.study_03;
/*
    动物操作类
*/
public class AnimalOperator {
   /* 
   // 这样写较为复杂
   public void useAnimal(Cat c) { // Cat c = new Cat();
        c.eat();
    }
    
    public void useAnimal(Dog d) {
        d.eat();
    }*/
	
	// 这样写毕竟好
    public void useAnimal(Animal a) {
        // Animal a = new Cat();
        // Animal a = new Dog();

        a.eat();
        // 不能使用子类的特有功能
//         a.lookDoor();
    }
}
-----
package com.study_03;
public class AnimalDemo {
    public static void main(String[] args) {
        // 创建动物操作类的对象,调用方法
        AnimalOperator ao =new AnimalOperator();
        Cat c = new Cat();
        ao.useAnimal(c);

        Dog d = new Dog();
        ao.useAnimal(d);
    }
}

多态中的转型

向上转型

• 从子到父
• 父类引用指向子类对象

向下转型

• 从父到子
• 父类引用转为子类对象

For example

定义三个类
Animal
Cat
AnimalDemo	// 测试类

package com.study_04;
public class Animal {
    public void eat() {
        System.out.println("动物吃东西");
    }
}
-----
package com.study_04;
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}
-----
package com.study_04;
public class AnimalDemo {
    public static void main(String[] args) {
        // 多态
        Animal a  = new Cat(); // 向上转型
        a.eat();
//        a.playGame(); // 编译看左边,Animal中没有playGame()这个方法

        /*Cat c = new Cat();
        c.eat();
        c.playGame();*/

        // 向下转型,这样就可以调用Cat类里面特有的方法了
        Cat c = (Cat) a;
        c.eat();
        c.playGame();
    }
}

---

抽象类

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

抽象类特点

抽象类和抽象方法必须使用abstract关键字修饰

public abstract class  类名()
public abstract void eat();

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类

抽象类不能实例化

Question:抽象类如何实例化呢?
参照多态的方式，通过子类对象实例化，这叫抽象类多态

抽象类的子类
1.要么重写抽象类中的所有抽象方法
2.要么是抽象类

For example

定义四个类
Animal
Cat
Dog
AnimalDemo	// 测试类

package com.study_02;
/*
*   抽象类
* */
public abstract class Animal { // 使用abstract关键字,抽象类
    // 定义一个抽象方法  
    public abstract void eat(); // 使用abstract关键字,抽象方法
    
    public void sleep() {
        System.out.println("睡觉");
    }
}
-----
package com.study_02;
// 定义一个猫类继承于动物类
public class Cat extends Animal {
	// 因为猫类不是抽象类，所以要重写动物类中的所有抽象方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
	// 猫类自己的方法
    public void play() {
        System.out.println("猫小乐");
    }
}
-----
package com.study_02;

public abstract class Dog extends Animal{

}
------
package com.study_02;

public class AnimalDemo {

    public static void main(String[] args) {
//        Animal a = new Animal(); // 是抽象类,不是具体的,抽象类不能被实例化
        Animal a = new Cat(); // 通过子类对象进行实例化
        a.eat();
        a.sleep();

        // 向下转型
        Cat c = (Cat) a; 
        c.play(); // 如果不进行转型,a是调用不了Cat类中特有的play()方法
        		  // 因为编译看左边,但是左边Animal类中并没有play()这个方法 
    }
}

抽象类的成员特点

成员变量
可以是变量
也可以是常量

构造方法
有构造方法，但是不能实例化

Question:构造方法的作用是什么呢?
用于子类访问父类数据的初始化

成员方法
可以有抽象方法:限定子类必须完成某些动作
也可以有非抽象方法:提高代码复用性

For example

定义三个类
Animal
Cat
AnimalDemo	// 测试类

package com.study_03;
/*
*   抽象类
* */
public abstract class Animal {
    private int age = 20;
    private final String city = "Nanjing";

    // 有构造方法，但是不能实例化
    public Animal(){}
	// 用于子类访问父类数据的初始化
    public Animal(int age) {
        this.age = age;
    }
    
    // 非抽象方法,提高代码复用性
    public void show() {
        age = 40;
        System.out.println(age);
        System.out.println(city);
    }
	
	// 抽象方法,限定子类必修要完成eat()方法
    public abstract void eat();
}
-----
package com.study_03;
public class Cat extends Animal{
	// 重写父类中的抽象方法
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
-----
package com.study_03;
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

---

接口

接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用Java中的接口更多的体现在对行为的抽象

接口特点

接口用关键字interface修饰

public interface 接口名 {}

类实现接口用implements表示

public class 类名 implements 接口名{}

接口不能实例化

Question:接口如何实例化呢?
参照多态的方式，通过实现子类对象实例化，这叫接口多态。

多态的形式:具体类多态，抽象类多态，接口多态

多态的前提
1.有继承或者实现关系;
2.有方法重写;
3.有父(类/接口)引用指向(子/实现)类对象

接口的实现类
1.要么重写接口中的所有抽象方法
2.要么是抽象类

接口的成员特点

成员变量
只能是常量
默认修饰符:public static final

构造方法
接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在
一个类如果没有父类，默认继承自Object类

成员方法
只能是抽象方法
默认修饰符: public abstract
关于接口中的方法，JDK8和JDK9中有一些新特性，后面再讲解

For example

package com.study_02;
public interface Inter {
    public int num = 10;
    public final  int num2 = 20;

    // 接口中是没有构造方法的, 因为接口是对行为进行描述
//    public Inter(){}

//    public void  show(){} // 接口里面不能有非抽象方法

     public abstract void method();
	// 接口里面 方法默认就是 public abstract
     void show();
}
-----
package com.study_02;
// 下面表示接口实际表现,但是系统隐藏了
//public class InterImpl implements Inter{
public  class InterImpl  extends Object implements Inter{ // 
    public InterImpl() {
        super();
    }
	
	// 重写接口里面的方法
    @Override
    public void method() {
        System.out.println("method");
    }

    @Override
    public void show() {
        System.out.println("show");
    }
}
-----
package com.study_02;
/*接口测试类*/
public class InterfaceDemo {
    public static void main(String[] args) {
    	// 参考多态实例的实现方式
        Inter i = new InterImpl();
//        i.num = 20; // 接口中成员变量默认被final修饰
        System.out.println(i.num);
        System.out.println(i.num2);
        System.out.println(Inter.num); // 接口中的成员变量默认静态修饰
    }
}

类和接口的关系

类和类的关系
继承关系，只能单继承，但是可以多层继承

类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口和接口的关系
继承关系，可以单继承，也可以多继承

抽象类和接口的关系

成员区别

抽象类
变量,常量;有构造方法;有抽象方法,也有非抽象方法

接口
常量;抽象方法

关系区别

类与类
继承，单继承

类与接口
实现，可以单实现，也可以多实现

接口与接口
继承，单继承，多继承

设计理念区别

抽象类
对类抽象，包括属性、行为

接口
对行为抽象，主要是行为

举个例子:
门和警报
所有门都有开门和关门的功能，部分们有警报的功能
那么就可以把开门关门功能写在门类中，警报功能写在接口中

---

内部类

内部类:就是在一个类中定义一个类。

举例:在一个类A的内部定义一个类B，类B就被称为内部类

内部类的访问特点
1.内部类可以直接访问外部类的成员，包括私有
2.外部类要访问内部类的成员，必须创建对象

内部类的定义格式

public class 类名 {
	修饰符 class 类名{
	}
}

For example

package com.study_01;
public class Outer {
    private int num = 10;
	// 简简单单调用一个内部类
    public class Inner {
        public void show() {
            System.out.println(num);
        }
    }
    // 通过方法调用内部类里面的方法
    public void  method(){
    	// 外部类调用内部类,必修要创建对象
        Inner i  = new Inner();
        i.show();
    }
}

成员内部类

按照内部类在类中定义的位置不同，可以分为如下两种形式
1.在类的成员位置:成员内部类
2.在类的局部位置:局部内部类

成员内部类，外界如何创建对象使用呢?

格式:  外部类名.内部类名对象名=外部类对象.内部类对象;
范例:  Outer.Inner oi = new Outer().new Inner();

package com.study_02;
public class Outer {
    public int num = 10;

    /*public class Inner{
        public void show() {
            System.out.println(num);
        }
    }*/

    private class Inner{
        public void show() {
            System.out.println(num);
        }
    }

    public void method() {
        Inner i = new Inner();
        i.show();
    }
}
-----
package com.study_02;
/*
* 测试类
* */
public class InnerDemo {
    public static void main(String[] args) {
        // 创建内部类对象，并调用方法
		// 调用public修饰的内部类
//        Outer.Inner oi = new Outer().new Inner();  // 不能私有的内部类
//        oi.show();
		// 调用private修饰的内部类
        Outer o = new Outer();
        o.method();
    }
}

局部内部类

局部内部类是在方法中定义的类，所以外界是无法直接使用，需要在方法内部创建对象并使用该类可以直接访问外部类的成员，也可以访问方法内的局部变量

For example

package com.study_03;
public class Outer {
    public int num = 10;
    public void method() {
        int num2 = 20;
        // 内部类写在外部类的方法里面
        class Inner {
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }

        Inner i = new Inner();
        i.show();
    }

}
-----
package com.study_03;
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

匿名内部类

前提:存在一个类或者接口，这里的类可以是具体类也可以是抽象类
本质:是一个继承了该类或者实现了该接口的子类匿名对象

new 类名或者接口名() {
	重写方法
};

For example

package com.study_04;
// 存在的接口
public interface Inter {
    void show();
}
-----
package com.study_04;

public class Outer {
    public void method() {
       /* new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };*/

//        show()

        /*new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();*/

        Inter i =  new Inter() {
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        };
        i.show();
    }
}
-----
package com.study_04;
public class OuterDemo {
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}