【JAVA】面向对象-4

今天继续学习面向对象剩下的几个知识点。

1. 面向对象特征--多态
2. final关键字
3. 接口

多态

多态：多态的意思是指同一种实物，在不同时刻所表现的状态不同。

同一个父类类型，父类可以表示任意子类。

使用多态的条件：

1.要有继承关系

2.要有重写

3.父类的引用指向子类对象

下面是体现多态的代码：

public class CarTest {
    public static void main(String[] args) {
        CarTest carTest=new CarTest();
        Car baoma=new BaoMa();
            baoma.door();
            baoma.drive();
            baoma.Length();
        System.out.println(baoma.money);

//编译期间看左边类,运行期间看右边
//编译期间  类型是父类类型,调用的是父类中定义的方法
//对于静态方法,编译和运行都看左边
//对于成员变量, 编译和运行都看左边
        System.out.println();
        Car aodi=new AoDi();
            aodi.drive();
            aodi.door();
            aodi.Length();
        System.out.println(aodi.money);

        System.out.println();
        carTest.charge(baoma);
        carTest.charge(aodi);

    }
    public void charge(Car car){
        System.out.println("给"+car+"车加油");
        car.drive();
    }

}


public abstract class Car {
    int money=0;

    abstract void door();


    public  void drive(){
        System.out.println("车能跑");
    }

    public static void Length(){
        System.out.println("车长6米");
    }


}



public abstract class Car {
    int money=0;

    abstract void door();


    public  void drive(){
        System.out.println("车能跑");
    }

    public static void Length(){
        System.out.println("车长6米");
    }


}


public class AoDi extends Car{
    int money=37000;
    String name="奥迪";
    @Override
    void door() {
        System.out.println("奥迪是无框门");
    }

    @Override
    public void drive() {
        System.out.println("奥迪车跑150km/h");
    }


    public static void Length(){
        System.out.println("奥迪车长7.5米");
    }
}

 

这是运行结果： 

 final关键字

final：是用来声明属性的，可以修饰类、属性和方法。

当final修饰属性时：修饰成员变量变为常量,值不可改变；修饰成员变量为常量,直接对其初始化赋值,建议使用static修饰：修饰的成员变量为常量.在定义时没有为其初始化,必须在某个构造方法为其赋值,这样每个对象中都有一个常量。

当final修饰类时：修饰的类不能被其他类继承。

当final修饰方法时：修饰的方法不能被子类重写。

下面是体现final关键字作用的代码：

public class test1 {
    public static void main(String[] args) {
        finalDemo f1=new finalDemo();
        finalDemo f2=new finalDemo(30);

        System.out.println(f1.b);
        System.out.println(f2.b);
        f1.fly();
        f2.fly();
    }
}

public class finalDemo {
    public static final int a=10;
    public final int b;

    public finalDemo(){
        b=20;
    }

    public finalDemo(final int b){
        this.b=b;
    }

    public final void fly(){
        System.out.println("起飞，哎，飞");
    }
}


public class Demo2 extends finalDemo{
//    @Override
//    public final void fly(){
//    final修饰的方法不能被重写
//    }

}

下面是运行结果：

接口 

接口：接口类似于一个抽象类，作用也与抽象类类似，但与抽象类不同的是抽象类可以定义成员变量和构造方法，而接口只能定义常量，抽象方法，静态方法和默认方法；抽象类可以定义非抽象方法，而接口只能定义抽象方法；其次，接口可以继承其他多个接口，和抽象方法只能继承一个。

接口用interface来声明

要使用一个接口时，在要继承的类名后加implement在加接口名

接口的特性：

• 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字
• 接口中方法可以是抽象的,静态的,默认的
• 接口中声明的属性默认为 public static final 的
• 接口不是被类继承了，而是要被类实现
• 接口不能实例化对象
• 与继承关系类似，接口与实现类之间存在多态性
• 一个接口能继承其它多个接口
• 当类实现接口的时候，类要实现接口中所有的抽象方法。否则，类必须
• 声明为抽象的类

 

下面是有关接口作用体现的代码：

public class Test {
    public static void main(String[] args) {
        Mtinterfacetml A=new Mtinterfacetml();
        A.fly();
        A.faceB();
        A.faceC();
    }
}

public class Mtinterfacetml implements MyInterface,MyInterfaceA{

    @Override
    public void fly() {
        System.out.println("Myinterface的实现");
    }

    @Override
    public void faceB() {
        System.out.println("MyinterfaceB的实现");
    }

    @Override
    public void faceC() {
        System.out.println("MyinterfaceC的实现");
    }
}


public interface MyInterface {
    public final static int a=10;
                        int b=20;
    public  void fly();

}


public interface MyInterfaceA extends MyInterfaceB,MyInterfaceC{

}


public interface MyInterfaceB {
    public void faceB();
}

public interface MyInterfaceC {
    void faceC();
}

下面是运行结果：

 

接口和抽象类可以 结合使用，下面是例子：

public class Test {
    public static void main(String[] args) {
        Car baoma=new BaoMa() ;
        Car aodi=new AoDi();
        door aodi2=new AoDi();
        engine baoma2=new BaoMa();

        baoma.drive();
        baoma.typedoor();
        baoma.typeengine();
        aodi.drive();
        aodi.typedoor();
        aodi.typeengine();
        System.out.println(aodi.name);
        System.out.println(baoma.money);

    }
}

public abstract class Car implements door,engine{
    int money;
    char name;

    public Car() {
    }

    public Car(int money, char name) {
        this.money = money;
        this.name = name;
    }

    public abstract void drive();
}

public interface door {
    public void typedoor() ;
}

public interface engine {
    public void typeengine();
}

public class BaoMa extends Car implements door,engine{
    @Override
    public void drive() {
        System.out.println("宝马车以100km/h行驶");
    }

    @Override
    public void typedoor() {
        System.out.println("宝马才用无框车门");
    }

    @Override
    public void typeengine() {
        System.out.println("宝马装有V8引擎");

    }
}

public class AoDi extends Car implements door,engine{
    @Override
    public void drive() {
        System.out.println("奥迪车以120km/h行驶");
    }

    @Override
    public void typedoor() {
        System.out.println("奥迪采用鸥翼门");
    }

    @Override
    public void typeengine() {
        System.out.println("奥迪装有V12引擎");
    }
}

运行结果：