javaSE-多态

目录

• instanceof关键字
• final关键字
• 抽象类和抽象方法
• 接口

instanceof关键字

https://www.cnblogs.com/huachuantingyumian/p/16207004.html

final关键字

• 当类使用final关键字修饰时，类不允许被继承。

public final class A{

}

• 当方法使用final关键字修饰时，方法不允许被重写。

public final void a()

• 当基本类型使用final修饰时，其值不可修改。
• 当引用类型使用final修饰时，引用类型不允许指向其他对象。

final int a = 10;//不允许修改值
final String s = "string";//不允许指向其他对象

抽象类和抽象方法

• 使用abstract关键字定义抽象类和抽象方法。

public abstract class A {
    public abstract void a();
}

• 允许在抽象类中定义具体方法。

public abstract class A {

    public abstract void a();

    public void a1()
    {
        System.out.println("a1");
    }
}

• 抽象类的子类必须实现其抽象方法，除非子类也是抽象类。

public class A1 extends A{
    @Override
    public void a() {

    }
}

public abstract class A1 extends A{

}

• 抽象类无法通过new关键字直接创建实例，只能创建包含实现的匿名内部类实例。

A a = new A() {
            @Override
            public void a() {
                
            }
        };

• 抽象类支持向上转型和向下转型

public abstract class A {
    public abstract void a();
}

public class A1 extends A{

    @Override
    public void a() {
        System.out.println("a");
    }

}

    public static void main(String[] args) {

        A a = new A1();
        a.a();
        A1 a1 = (A1) a;
        a1.a();

    }

接口

• 使用interface关键字定义接口。
• 接口中只能含有public的抽象方法和public static final的变量。
• 接口中定义方法默认使用public修饰，定义变量默认使用public static final修饰。

public interface A{
	int a = 10;
	void A();
}

• 可以使用default关键字为接口中的方法提供默认实现。

public interface A{
	default void A(){
	
	};
}

• 一个类可实现多个接口

public interface Eat {
    void eat();
}

public interface Drink {
    void drink();
}

public class InterfaceTest implements Eat, Drink {
    @Override
    public void eat() {
        System.out.println("eat");
    }

    @Override
    public void drink() {
        System.out.println("drink");
    }
}

• 对象可以向上转型为其实现的接口

public static void main(String[] args) {
        Eat eat = new InterfaceTest();
        eat.eat();
        Drink drink = new InterfaceTest();
        drink.drink();
    }

//eat
//drink

• 支持向下转型

    public static void main(String[] args) {
        Eat eat = new InterfaceTest();
        eat.eat();
        InterfaceTest interfaceTest = (InterfaceTest) eat;
        interfaceTest.eat();
    }

//eat
//eat

标签：关键字,void,抽象类,多态,eat,public,javaSE,final
来源： https://www.cnblogs.com/huachuantingyumian/p/16211481.html