java第十一天学习笔记

java第十一天学习笔记

一、多态(动态绑定机制)

多态的概述

1.多态概述

​ 某一个事物，在不同时刻表现出来的不同状态。
​ 举例： Cat c=new Cat();
​ Animal a=new Cat();
​ 猫可以是猫的类型。猫 m = new 猫();
​ 同时猫也是动物的一种，也可以把猫称为动物。动物 d = new 猫();

2.多态前提

​ a:要有继承关系。
​ b:要有方法重写。 其实没有也是可以的，但是如果没有这个就没有意义。
​ c:要有父类引用指向子类对象。
​ 父 f = new 子();

3.多态的成员访问特点

a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。
(静态和类相关，算不上重写，所以，访问还是左边的)

4.多态的好处和弊端

多态的好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)

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

5.向上转型和向下转型

向下转型：把父类的引用强制转换为子类的引用

向上转型：父类引用指向子类对象 向上转型。

 Fu fu = new Zi();
        System.out.println(fu.num);
        Zi zi2= (Zi) fu;
        System.out.println(zi2.num);

二、抽象类

1.抽象类的概述

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

2.抽象类的成员特点

​ a:抽象类和抽象方法必须用abstract关键字修饰
​ 抽象类格式: abstract class 类名 {}
​ 抽象方法格式: public abstract void eat();

​ 非抽象方法，子类可以重写，也可以不重写；抽象方法，强制子类重写。

​ b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
​ c:抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
​ 用于子类访问父类数据时的初始化
​ d:抽象类不能直接实例化那么，抽象类如何实例化呢?
​ 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
​ e:抽象类的子类
​ 要么是抽象类
​ 要么重写抽象类中的所有抽象方法

3.抽象类的成员特点

A:抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量。
b:构造方法：有。
用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。

B:抽象类的成员方法特性：
a:抽象方法 强制要求子类做的事情。
b:非抽象方法 子类继承的事情，提高代码复用性。

4.abstract不能和哪些关键字共存?

	private    冲突。矛盾。abstract 强制子类重写。但是private 是私用的，子类都不能继承何谈重写
	final      冲突，矛盾，final修饰的方法，子类不能重写 但是abstract 强制子类重写
	static     不能共存 无意义。static 方法不参与重写 但是abstract 强制子类重写
	 
	 // 一个类如果没有抽象方法，可不可以定义为抽象类 ? 如果可以，有什么意义 ?
     //可以 。外界不能创建该类对象。

三、接口

1.接口的概述

定义接口 interface 接口里面就可以定义一个扩展的功能，将来有哪些事物，想要具备这些额外功能，可以来实现这个接口，然后重写这个功能

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

​ 接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。

​ 接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口特点

​ a:接口用关键字interface表示 格式: interface 接口名 {}
​ b:类实现接口用implements表示 格式: class 类名 implements 接口名 {}
​ c:接口不能实例化
​ 那么，接口如何实例化呢?
​ 按照多态的方式来实例化。
​ d:接口的子类
​ a:可以是抽象类。但是意义不大。
​ b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

//接口不能创建对象
// FireInterface f=new FireInterface(); //报错
//  子类Dog  实现implements   FireInterface父接口
//使用多态的形式来调用子类重写过后的方法
//父接口指向子类对象

public class MyTest {
    public static void main(String[] args) {
        //接口：interface 用来定义一些扩展额外的功能，哪些事物想要具备扩展功能，可以实现这个接口，重写接口中的抽象功能。
        MyInterface myInterface = new DD();
        myInterface.hehe();
        myInterface.show();
    }
}

interface MyInterface{
    public abstract void show();
    public abstract void hehe();
}

abstract class AA implements MyInterface{
    public abstract void haha();
}

class CC extends AA{
    @Override
    public void show() {
    }

    @Override
    public void hehe() {
    }

    @Override
    public void haha() {
    }
}

class DD implements MyInterface{
    @Override
    public void show() {
    }

    @Override
    public void hehe() {
    }
}

2.接口的成员特点

接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。

public class MyTest {
    public static void main(String[] args) {
//接口的特点
//1.接口中只能定义常量不能定义变量 并且还是公共的静态常量 因为存在默认修饰符 public static final
//2.接口中没有构造方法
//3.接口中的全部是抽象方法，没有非抽象方法 方法前面有默认修饰符 public abstract

        System.out.println(MyInterface.NUM);
        System.out.println(DD.NUM);
        MyInterface myInterface = new DD();
        System.out.println(myInterface.NUM);
        DD dd = new DD();
        System.out.println(dd.NUM);
    }
}
//接口的特点
interface MyInterface{
   public static final int NUM=200;
   //成员变量前面的默认修饰符是  public static final
   int a=20;
   //方法前面存在默认修饰符 public abstract
    public abstract void hehe();
    int haha();
   /* public void test(){  }*/
}

class DD implements MyInterface{
    @Override
    public void hehe() {}
    @Override
    public int haha() {return 0;}
}

3.类与类,类与接口,接口与接口的关系

a:类与类：
继承关系,只能单继承,可以多层继承。
b:类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口：
继承关系,可以单继承,也可以多继承。

//类跟类之间的关系：extends 继承关系，并且是单继承，支持多层继承。
//类跟接口的关系：implements 实现关系，并且可以多实现。一个类可以实现多个接口。
//一个类在继承一个父类的同时还可以去实现多个接口
//接口跟接口直接是继承关系。并且可以多继承。一个接口可以继承多个接口。

4.抽象类与接口的区别

A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类：继承，单继承
类与接口：实现，单实现，多实现
接口与接口：继承，单继承，多继承

//Java中类跟类只能单继承。
//一个类可以实现多个接口。JDK1.8之前，接口中不能定义非抽象方法

C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。

注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用，能够 弥补单继承所带来的不足。（这个default修饰的方法 ，可以给给出方法体，对方法功能具体实现。）

JDK1.8之后，也可以在接口中定义静态方法

补充：JDK1.9 接口中可以定义私有方法与私有静态方法

public class MyTest {
    public static void main(String[] args) {
        //抽象类跟接口的区别
        //抽象类中，可以定义成员变量和可以定义常量。
        //接口中定义的都是公共的静态常量
        //抽象类中有构造方法，接口中没有构造方法这一说。
        //抽象类中，既可以定义抽象方法，也可以定义非抽象方法
    }
}

abstract class DD{
    int num;
    public static final int AA=200;

    public DD() {}
    public abstract void show();
    public void hehe(){}
}
interface AA{
    public static final int num=20;
    public  abstract void aa();
}