Java学习12

最新推荐文章于 2024-10-01 09:29:45 发布

那夜风轻摇

最新推荐文章于 2024-10-01 09:29:45 发布

阅读量1.9k

点赞数 29

文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/2302_79866417/article/details/137244965

版权

一.final关键字：

1.基本介绍：

final可以修饰类、属性、方法和局部变量。
final修饰的类不可以被继承；final修饰的方法不可以被覆盖或重写；final修饰的类的属性不能被更改；final修饰的局部变量被修改（局部常量）。

2.final的细节和注意事项：

（1）final修饰的属性叫做常量，一般以XX_XX_XX来命名。

（2）final修饰的属性在定义时必须初始化（赋初值），并且以后不能被修改。

class AA {
   public final double TEX_RATE1 = 0.0;
   public final double TEX_RATE2;
   public final double TEX_RATE3;
   public AA(){
      TEX_RATE2 = 1.1;
   }
   {
      TEX_RATE3 = 2.2;
   }
}

注：可以在构造器和代码块中赋值；如果final修饰的是静态代码块，则初始化的位置只能是在静态代码块中。

（3）final不能继承，但是可以实例化对象。

（4）如果类不是final类，但是含有final方法，方法可以被继承，但是不能被重写。

二.抽象类：

1.抽象类细节：

abstract关键字修饰的类叫做抽象类，abstract修饰的方法是抽象方法，抽象方法没有方法体。
抽象类不能被实例化，抽象类可以没有抽象方法，有抽象方法的类一定是抽象类
abstract只能修饰类和方法，不能修饰属性和其他。
抽象类可以有任意成员，如：非抽象方法、构造器、静态属性等
如果一个类继承了抽象类，那么该子类必须实现抽象类的所有方法，除非它自己也声明为抽象类。
抽象类不能使用private、final、static来修饰，这些关键字都是和重写相违背的。

三.接口（interface）：

1.接口基本介绍：

接口就是给出一些没有实现的方法封装到一起，在某个类实现接口时（implements），在类内实现接口的抽象方法。

public class interface00 {
    public static void main(String[] args) {
        Mysqldb mysqldb = new Mysqldb();
        t(mysqldb);
        Oracle oracle = new Oracle();
        t(oracle);
    }
    public static void t(DBinterface db){
        db.connect();
        db.close();
    }
}
 class Mysqldb implements DBinterface{
    @Override
    public void connect() {
        System.out.println("Mysql开启");
    }

    @Override
    public void close() {
        System.out.println("MySQL关闭");
    }
}

2.接口的注意事项和细节：

接口不能被实例化，接口中所有的方法都是public abstract方法；接口中抽象方法，可以不用abstract修饰。
一个类既继承父类又实现接口，要求继承在前实现在后，一个类可以同时实现多个接口。
一个类实现接口，就必须将该类的所有方法都实现，使用alt+enter快捷键来实现。
抽象类实现接口时，可以不实现接口的抽象方法。
接口不能继承其他的类。但是可以继承多个别的接口，接口的修饰符只能是public和默认。
接口中的属性，是public static final修饰的，接口中的属性以接口名.属性名来访问。

3.接口与继承的区别：

子类继承了父类，就自动拥有父类的功能，如果子类需要拓展功能，可以通过实现接口的的方式拓展，实现接口是对单继承机制的一种补充。

接口在一定程度上实现代码解耦【接口规范性+动态绑定机制】

4.接口类型的多态：

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口体现的多态：接口类型的变量可以指向实现了IF接口的对象实例
       IF if01 = new Monster();
       if01 = new Car();
       //继承体现的多态：父类类型的变量a可以指向继承AAA子类的对象实例
       AAA a = new BBB();
       a = new CCC();
    }
}
interface IF{}
class Monster implements IF{};
class Car implements IF{};
class AAA{

}
class BBB extends AAA{};
class CCC extends AAA{};

public class InterfacePolyParameter {
    public static void main(String[] args) {
       //创建接口多态数组
       Usb [] usbs = new Usb[2];
       usbs[0] = new Phone();
       usbs[1] = new Camera();
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();
            if(usbs[i] instanceof Phone){//判断运行类型
                ((Phone)usbs[i]).work();//向下转型
            }
        }
    }
}

interface Usb{
    void work();
};
class Phone implements Usb{
    public void call(){
        System.out.println("手机可以打电话");
    }

    @Override
    public void work() {
        System.out.println("手机工作中");
    }
};
class Camera implements Usb{
    @Override
    public void work() {
        System.out.println("相机工作中");
    }
};

5.接口多态传递：

类实现了子接口，子接口继承了父接口，实际上相当于类实现了父接口。

public class InterfacePolypass {
    public static void main(String[] args) {
        Ig ig = new Teacher();
        Ih ih = new Teacher();
    }
}
interface Ih{};
interface Ig extends Ih{};
class Teacher implements Ig{

}