抽象类与关键字

1.Final关键字

<1>使用final修饰的类不可以存在子类。

<2>使用final修饰的方法不能被子类重写

<3>使用final修饰的变量是常量，常量是不可被修改的。（常量命名为大写字母与下划线）

final int a = 1;

常量是不可被修改的。

 

2.1抽象类与接口

 

## abstract抽象类：

必须要存在子类继承该类完成方法体。这其中抽象类中是无方法体定义，以“ ；”结束句子，用于不确定方法内容的时候。

只要一个方法是抽象的，这个类就必须是抽象的。被abstract修饰不能被构造对象。（毕竟含有无方法的未知部分）

一个类中含有抽象方法这个类一定是抽象类。

一个类中可以无抽象方法。

含有private（因为是私有无法重写不可以与抽象共存，子类无法覆盖）,static（修饰的部分属于类，可以直接使用类名使用其中方法）,final

抽象类一定是父类需要子类覆盖方法后才能实例化。abstract类没方法体的实现也无法创造对象，必须要实现方法，抽象类中含构造方法，给子类的初始化。

 

## interface接口：

使用语法是：修饰符 class 类名 implements 接口1，接口2{......}

 

2.2接口与抽象类

 抽象类需要被继承extends，而且只可以单继承；接口需要被实现implements而且可以多实现。

抽象类中可以定义抽象方法，子类在继承抽象类后，可以直接 使用其中的非抽象方法。接口中只能定义抽象方法，必须由子类去实现。

例子：（小石榴单推人用小石榴写个例子，(。・ω・。)是编剧最喜欢的 “弗洛伊德人格理论！” ）

<1>父类（是一个抽象类），其余继承父类的子类，创造一个接口，创造链接接口的类。

public abstract class Freud {
    abstract void person();
}
//此处是父类freud

public class Id extends Freud {
    @Override
    void person() {
        System.out.println("我是你的本我,生而有我之我");
    }
}
//1号子类

public class Ego extends Freud{
    @Override
    void person() {
        System.out.println("我是你的自我,探寻真我之我");
    }
}
//2号子类

public class Superego extends Freud {
    @Override
    void person() {
        System.out.println("我是你的超我,黄金白银之美");
    }
}
//3号子类

//类与类之间是继承关系，但类与接口之间可是实现关系
public interface Personality {
//接口内全部都是抽象方法
//public static final int，void前默认的句子(固定)
    final int a = 1;
    int num = 3;
//num显示变为斜体；static，final也会出现相同情况，接口定义的成员变量即是常量，接口内全部都为全局常量，因此无法改变
    void human();
}
//定义一个接口

public class Human implements Personality{
    @Override
    public void human() {
        System.out.println("并非生而自知的我们");
    }
}
//使用接口

package capo;
import static capo.Personality.num;//此处接口的num常量
public class Person3 {
    public static void main(String[] args) {
        Id id = new Id();
        function(id);//id为Id类型的变量
        //这两个其中可以将等号看作为箭头，id与freud同时指向new Id（）这么一个地址
        //多态始终是子类在做变化
        Freud freud = new Id();
        function(id);//freud为Freud类型的变量
        //Id具有两种类型，Freud类型与Id类型，多态
        Ego ego =new Ego();
        function(ego);
        Superego superego =new Superego();
        function(superego);
        Human human =new Human();
        human.human();
        System.out.println(num);
    }
    static void function(Freud freud){
        freud.person();
    }
}
//运行结果

 

 3.多态

继承是多态得以实现的基础，由于参数类型的不同导致执行效果各异的现象，即是多态。

多态的两种形式：1.方法的重载；2.对象的多态性（方法重写）

多态始终是子类在变化。

//这两个其中可以将等号看作为箭头，id与freud同时指向new Id（）这么一个地址，只不过使用的变量属于两种类型
//多态始终是子类在做变化
Freud freud = new Id();
function(id);//freud为Freud类型的变量
//Id具有两种类型，Freud类型与Id类型，多态

结束啦结束啦！
------------------------分割线-------------------------

( •̀ ω •́ )✧