Java学习笔记8-面向对象续（多三大特性之一多态）

1.多态

        多态：一种事物的多种形态，多种表现形式。多态指的是成员方法的多态，一个行为（成员方法）的实现方式。

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

多态的是实现效果：配合子类方法的重写，当父类引用指向不同的子类对象同一个方法具有不同的实现方式。（注：父类引用对子类新增内容不可见）

//实例代码-多态的实现
public class Class001_Polymorphic {
    public static void main(String[] args) {
        //对应类型的数据赋值给对应类型的变量
        int i = 1;
        Person p = new Person();
        Student s = new Student();

        //多态的最终体现
        Person person = new Teacher();
        person.test();
        //父类对子类新增方法不可见
        //prson.test1()
    }
}
//定义一个父类
class Person{
    void test(){
        System.out.println("Person");
    }
}
//定义子类
class Student extends Person{
    void test(){
        System.out.println("Student");
    }
}
//定义子类
class Teacher extends Person{
    void test(){
        System.out.println("Teacher");
    }
    //子类新增方法
    voidd test1(){
         System.out.println("新增方法");
    }
}

2.对象的转型（casting）

        引用变量只能调用它编译类型的方法，不能调用它运行类型的方法。这时，我们就需要进行类型的强制转换！（比如多态时，只能参照父类的方法，如果父类有方法可以使用或者在子类重写父类中方法然后调用，对于子类中新增的方法，多态不能调用，所以可以通过类型转换中的强制转换进行调用）。

(1)向上转型：自动类型提升（父类>子类）

 (2)向下转型：强制类型转换     

             格式：子类类型|实现类类型  引用 = (子类类型|实现类类型)父类引用|接口引用; 

//实例代码-类型转换
public class Class001_Cast {
    public static void main(String[] args) {
        //多态自动类型提升（向上转型）
        Person p = new Student();
        //需求: 调用子类中独有的study
        //向下转型  从父类引用转为对应类型的子类引用,就可以调用子类中的所有内容

        if(p instanceof Teacher){
            //强制类型转换（向下转型）
            Teacher s = (Teacher)p;
            s.study();
        }else if(p instanceof Student){
            Student s = (Student)p;
            s.study();
        }
        //引用 instanceof 类型:
        //判断前面的引用是否指向后面类型的对象或者后面类型子类的对象,是->true  不是->false
        System.out.println(p instanceof Person);  //true
        System.out.println(p instanceof Object);  //true
        System.out.println(p instanceof Student); //true
        System.out.println(p instanceof Teacher); //false
    }
}

class  Person{}

class Student extends Person{
    void study(){
        System.out.println("学习");
    }
}

class Teacher extends Person{
    void study(){
        System.out.println("老师学习!!!!");
    }
}

注：ClassCastException 类型转换异常

  原因：引用强转类型的时候,没有转为指向的子类对象类型,转为了其他子类类型,出现的异常

预防出出现类型转换异常->instanceof 运算符

引用 instanceof 类型: 判断前面的引用是否指向后面类型的对象或者后面类型子类的对象,是->true 不是->false

3.抽象类

        抽象类被abstract修饰的类

        通过抽象类，就可以做到严格限制子类的设计，使 子类之间更加通用。

        抽象方法存在抽象类中，也是需要被abstract修饰，抽象方法中没有方法体。

抽象类特点：

1.抽象类不能实例化
2.抽象类可以定义任意内容(属性,功能(抽象的方法,具体的方法))
3.抽象方法必须要求被重写
4.抽象类使用: 通过具体子类对象使用
    具体子类: 重写所有的抽象方法 + 按需新增
    抽象子类: 按需重写抽象方法 + 按需新增
5.一个抽象方法一旦被重写,可以不再被重写,根据需求决定
6.abstract不能与private,final,static,native 一起使用
7.抽象类可以实现多态

//实例代码-抽象类
public class Class001_Abstract {
    public static void main(String[] args) {
        //Develop d = new Develop();
        //具体子类对象
        Develop java = new Java();
        java.work();
        java.sleep();
        //java.mr();
    }
}
//父类
abstract class Develop {
    //方法体: 不知道怎么写,不知道写什么
    public abstract void work();
    //具体方法
    public void sleep(){
        System.out.println("胡吃海喝!!!!");
    }
}
//子类
class Java  extends Develop{
    //方法的重写
    @Override
    public void work() {
        System.out.println("服务器端开发");
    }
    //新增功能
    public void mr(){
        System.out.println("与测试,产品,谈论...探讨...");
    }
}
//抽象子类
abstract class Web extends Develop{
    //public abstract void work();
    public void haha(){
        System.out.println("每天哈哈傻笑...");
    }
}

4.接口

        接口可以理解为是一个特殊的抽象类，接口可以帮助子类定义规范。接口是两个模块之间通信的标准，通信的规范。

接口的定义：interface 接口名{}

组成：（1）访问修饰符只能是public或默认

           （2）接口名和类名采用相同的命名机制

            （3）常量-接口中的属性只能是常量

             （4）接口中的属性只能是常量-公共的静态的常量 public static final (修饰符可以任意省略)

             （5）接口中的方法只能是：public abstract公共的抽象的方法 public abstract （修饰符可以任意省略）

使用：（1）子类通过 implements 来实现接口中的规范

           （2）接口不能实例化

           （3）接口需要通过实现类的对象使用

           （4）具体的实现类 : 重写所有的冲向方法 + 按需新增    

                     抽象的实现类 : 按需重写 + 按需新增

注：接口可以多实现,类只能单继承

//实例代码-接口
public class Class001_Interface {
    public static void main(String[] args) {
        System.out.println(MyInterface.PI);
        //根据具体的实现类的对象使用
        MyImpl my = new MyImpl();
        my.test1();
        my.test1();
        my.haha();
    }
}
//接口
interface MyInterface{
    //公共的静态的常量
    double PI = 3.14;
    //公共的抽象的方法
    public abstract void test1();
    void test2();
}
interface A{
    void a();
}
interface B{
    void b();
}
//具体实现类 多继承多个接口
class MyImpl  extends Object implements MyInterface,A,B {
    @Override
    public void test1() {

    }
    @Override
    public void test2() {
    }
    //新增内容
    public void haha(){}
    @Override
    public void a() {
    }
    @Override
    public void b() {
    }
}
//抽象实现类
abstract class MyImpl2 implements MyInterface{
    @Override
    public void test1() {
    }
}

注：

1.父类与接口无法完全相互代替,如果可以建议使用接口,因为接口可以多实现非常灵活
2.类与类之间只能继承
  类与接口之间,只能是类实现接口
  类与类之间只能单继承
  类与接口之间可以多实现
  接口与接口之间,可以多继承
3.接口可以实现多态  接口引用指向实现类对象