java_final和抽象类/方法和接口

final

一、final关键字的作用

• 修饰变量
  被他修饰的变量不可以改变，一旦赋了初始值，就不能被重新赋值。只能赋值一次
• 修饰方法
  该方法不可以被子类重写，但是可以被重载。final不能修饰构造方法
• 修饰类
  修饰的类不能被继承。

二、常用的final类

• System
• Math
• String

三、final的命名规则

• 全部大写

四、关于使用final定义方法

package Day5;

public class Maths {
//    模拟Math类
//    使用final字段，不能被继承，不能被重写，但是可以被重载
    public static final double PI=3.14;

    //对于Math类，他都是静态方法，都可以用类名直接.方法名
    //但是这里对构造函数使用private，这样就可以控制别包里的类，不能创造对象 只能使用类名.
//    方法，来使用
    private Maths(){}

    public static final double abs(double d){
        if(d>0){
            return d;
        }else {
            return -d;
        }
    }
}

五、关于final修饰对象引用

package Day5;

public class Dog {
    private String name;
    public static void main(String[] args) {
        final Dog dog = new Dog();
        dog.name = "菲菲";
        dog.name = "丫丫";//这里为什么没有报错呢
//        因为dog.name是在堆内存里，他的地址是dog引用，此时改的是dog
//         引用指向的空间里的name，所以他没有报错       
        
//        dog = new Dog();  这里会报错  因为final修饰的是dog这个对象的引用
//        而，给dog赋值new Dog，说明是开辟了一个新的对象赋值给他，那么他的引用地址就变了
//        但是final修饰的自段只能赋值一次，所以他报错了        
                
    }
}

抽象类和抽象方法

对一个类不想让他实例化就可以把他定义为抽象类
抽象类，不能new。
抽象方法定义了一个功能，没有给出实现。要求子类必须重新。

如果一个类里使用了抽象方法，那么他必须也是抽象类。

同样是override 有两种情况

• 非抽象方法要override
• 抽象方法要implements，即要实现

一个抽象类中最少0个抽象方法（此时抽象类不能new），最多所有方法都是抽象的

抽象类具体的用途就是：给出了一个类的模板，可以按照这个模板给出具体的实现

接口

他不是继承is-a，他是有什么功能的意思。

父类只能有一个，但是接口可以有多个
接口中所有的变量都是全局静态变量。
接口中所有方法都是全局抽象方法，即得override使用 JDK<=1.7
接口不能new，也没有构造方法，也不会自动继承某个类

package Day5;

public class Test {
    public static void main(String[] args) {
        System.out.println(Flyable.pi);//他可以通过接口名直接调用 说明Flyable接口的pi字段有static修饰
//        Flyable.pi=3.15;此时却报错了 说明Flyable接口的pi字段有final修饰
        
    }
}

接口的方法要实现，如下：

Flyabe类

package Day5;

public interface Flyable {
    double pi =3.14; //pi变成斜体了

    void fly();

}

Bird类

package Day5;

public class Bird extends Animal implements Flyable{
//对接口的方法要进行实现
    @Override
    public void fly() {

    }
}

接口做为形参

package Day5;

public class Test {
    public static void main(String[] args) {
        Bird bird=new Bird();
        fly(bird);

        fly( new Plane());
    }

    /**
     * 形参是接口，实参可以是接口的任意一个实现类的对象
     * @param flyable
     */
    public static void fly(Flyable flyable){
        flyable.fly();
    }
 /*   public void fly(Bird bird){
        bird.fly();
    }
    public void fly(Plane plane){
        plane.fly();
    }*/
}

接口可以继承接口

package Day5;

public interface MyFlyable extends Flyable{
//    接口虽然不能被继承，但是接口可以继承接口
//    但是此时使用MyFlyable接口的类，不光要实现MyFlyable的所有抽象方法，
//    还要实现Flyable的所有抽象方法
}

要点

• 子类通过implements来实现接口中的规范
• 接口不能创建实例，但是可以用于声明引用变量类型 Flyable f = new Bird();
• 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是 public的
• jdk1.8（不包含1.8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性，普通方法、构造方法
• jdk1.8之后（包含1.8），接口中包含普通的静态方法，默认方法

总结1：接口的组成

• 接口和数组、类、抽象类是同一个层次的概念
• 成员变量：接口中所有的变量都使用public static final修饰，都是全局静态常量
• 成员方法：接口中所有的方法都使用public abstract修饰，都是全局抽象方法
• 构造方法：接口不能new ,也没有构造方法
• 接口做方法的形参，实参可以是该接口的所有实现类

总结2：jdk1.8之后的变化

变化：可以有抽象方法

• 抽象方法子类必须实现
• 非抽象方法：
  • 1.static修饰，不能被实现类重写，只能通过接口名调用
  • 2.default修饰，类可以继承也可以重写，但是只能通过对象名调用(在重写中必须去掉default关键字)

总结3：实现非抽象方法的目的

• 解决实现该接口的代码重复问题（如果是他的抽象方法那么他都得重写，但是default方法可以写默认的方法体，不想重写的时候可以直接用）