抽象类、接口及final

1. 什么是抽象类，它在什么时候使用？
2. 什么是接口？它的作用是什么？
3. final是什么，作用是什么？

抽象类

1.当父类的一些方法不能确定是什么的时候，可以使用abstract关键字来修饰该方法[抽象方法]，用abstract来修饰该类[抽象类]。方法只声明不实现。

 

2.子类要去实现其父类的抽象方法！

abstract class Animal{
    String name;
    int age;
    abstract public void cry();//不要在这后面加{},这也算是实现！
}
 
//当一个类继承的父类是抽象类的话，需要把抽象类中的抽象方法全部都实现！
class Cat extends Animal{
    @Override
    public void cry(){
        //do nothing...
    }
}

 

3.关于抽象类需要知道的几点：   

• 抽象类不可实例化，也就是不能new
• 抽象类可以包含属性、方法、构造方法，但是构造方法不能用来new实例（抽象类本来就不能new），只能用来被子类调用！
• 抽象类只能被继承
• 抽象类不一定要包含抽象方法。如果抽象类包含有抽象方法，那么该抽象方法不可以有任何实现(即使是在其后加了{}也不行)，并且继承该抽象类的子类必须将实现该抽象方法
• 一旦类包含了abstract方法，则这个类必须声明为abstract！
• 抽象类中的抽象方法必须没有方法体！{}也不能有
• 继承了抽象类的子类必须要实现父类中的抽象方法！

抽象类的意义在于：为子类提供统一的、规范的模板。

 

“ 类可以不实现抽象类和接口声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。”这句话是正确的，怎么理解呢？请看实例：

package com.testabstract;
abstract class Ab_stract {
       abstract void fun1() ;
       abstract void fun3();
       abstract void fun4();
       public void fun2() {
             System.out.println("Hello World");
       }
}
public abstract class TestAbstract02 extends Ab_stract{
       public void fun1() {
             System.out.println("Hi!Java");
       }
       
       public void fun2() {
             System.out.println("hello");
       }
       
       //如果fun4()方法不打算去实现的话也是可以的，但是这样你的TestAbstract02类就要为abstract
}

所以说的确可以不去实现抽象父类的所有抽象方法，但是此时你的继承子类就必须要声明为abstract抽象类

 

“ 抽象类可以在不提供接口方法实现的情况下实现接口。”这句话又怎么理解呢？请看实例：

package com.testabstract;
interface Bbb{
       public void function1();
       public void function2();
       public void function3();
}
abstract class Aaa implements Bbb{
       abstract void fun1() ;
       abstract void fun3();
       abstract void fun4();
       public void fun2() {
             System.out.println("Hello World");
       }
}

抽象类Aaa实现了接口Bbb，但是其中并没有去实现接口Bbb中的任何一个方法，但是Eclipse却没有报任何的错误，为什么呢？原来是因为接口中的方法，本来就是abstract的。总之就是抽象类当中不用去实现该抽象类所实现的接口中的方法。

---

不能放在一起的修饰符：final和abstract，private和abstract，static和abstract，因为abstract修饰的方法是必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时期子类都覆盖不了这个方法，final是不可以覆盖，private是不能够继承到子类，所以也就不能覆盖，static因为静态属于字节码，不需要对象就可以运行，而抽象方法没有方法体，运行没有意义，所以不能共存

 

---

 

接口（抽象中的抽象）

1.接口的语法格式：

interface 接口名{
        方法声明；//方法不能有主体！仅仅只是声明！
}

 

2.实现接口的方法：

implements 接口名

 

3.

• 当一个类实现了一个接口，就要求该类把这个接口的所有方法统统实现（这一点和抽象类类似）
• 接口不能被实例化（这一点和抽象类类似）
• 接口中的方法默认是public的
• 接口中的方法都不能有方法体！即不能实现它；抽象类中只有抽象方法不能有方法体，不是抽象方法的可以有方法体。
• 一个类可以实现多个接口，这就是多重继承
• 接口中可以有变量！但是需要注意，该变量不能用private和protected修饰，并且本质上是static，不管你是否加了static关键字。而且还是final的。也就是默认是public static final，如果要访问接口中的常量，直接使用"接口名.常量名"即可
• 在Java开发中，我们经常把常用的变量，定义在接口中，作为全局变量使用
• 一个接口不能继承其他的类，但是可以去继承其它接口，也就是接口可以去继承多个接口

 

继承和接口的区别

Java只能是单继承，但可以多实现接口，以此实现多继承。继承是层级的。实现接口可以看作是对继承的一种扩充

 

利用接口实现多态：

interface Car{
    String getName();
    int getPrice();
}
 
class BMW implements Car{
    //实现某个接口就要去实现接口中的方法
    public String getName(){
        return "BMW";
    }
    public int getPrice(){
        return 300000;
    }
}
 
class CheryQQ implements Car{
    //实现某个接口就要去实现接口中的方法
    public String getName(){
        return "CheryQQ";
    }
    public int getPrice(){
        return "200000";
    }
}
 
public class CarShop{
    private int money=0;
 
    public void sellCar(Car car){//重点在这里，这里是一个接口
        System.out.println("车型:"+car.getName()+"单价:"+car.getPrice());
        money+=car.getPrice();
    }
 
    public int getMoney(){
        return money;
    }
    public static void main(String args[]) {
       CarShop c = new CarShop();
       CheryQQ cq = new CheryQQ();
            //cq是CheryQQ类型的
       c.sellCar(cq);
    }
}

 

类可以不实现抽象类和接口声明的所有方法，当然，在这种情况下，类也必须得声明成是抽象的。

 

final关键字：

final可以修饰变量或方法

在某些情况下，程序员可能有以下需求：

1.当不希望父类的某个方法被子类覆盖（override）时，可以用final关键字修饰

2.当不希望类的某个变量的值被修改，可以用final修饰（final变量及方法是可以被继承的！）

3.当不希望类被继承时，可以用final修饰

 

也就是说：

• 被final修饰的类不能被继承
• 当父类中某个方法被final修饰时，子类不能去覆盖它
• 被final修饰的某个变量，它的值不能被修改

final使用应注意的事项：

• 使用final时，应注意，final修饰的变量必须在定义时就赋予初值！不可先定义后赋初值！
• final修饰的变量又叫常量，一般用xx_xx_xx来命名