Java中关于final、抽象、接口

final

final:【英文表示最终的最后的】
    1.被final修饰的变量不可以被改变，也被称为常量
    【包括成员变量和局部变量】
    2.被final修饰的方法不可以被重写
    3.被final修饰的类不可以被继承

[总的来说final就是不可变]

1.被final修饰的变量不可以被改变，也被称为常量

创建一个Diamods class

public class Diamods {
//public class Diamods {
    final int weight = 10;//该钻石为10克拉的。

    public static void main(String[] args) {
        Diamods d=new Diamods();
        d.weight=15;//运行后报错：无法为最终变量weight分配值
    }
}

上面是成员变量无法改变，下面的局部变量也是如此

public class Diamods {
//public class Diamods {
    final int weight = 10;//该钻石为10克拉的。

    public static void main(String[] args) {
        //Diamods d=new Diamods();
        //d.weight=15;//运行后报错：无法为最终变量weight分配值

        final int a =10;
        a=20;//运行后报错：无法为最终变量a分配值
    }
}

 2.被final修饰的方法不可以被重写

 在Diamods中写入方法

这个样子是可以重写的一旦加上final就不可以了
 public void bling(){
         System.out.println("钻石是闪闪亮的");
     }

 创建子类PinkDiamods

public class PinkDiamods extends Diamods {
   
    public void bling() {
        //前面没有加final时这个方法就可以写。
        //前面的bling加上final后就会报错
        System.out.println("粉色的钻石也是闪闪亮的");
    }
}

此时在方法前面加上final

final public void bling(){
        System.out.println("钻石是闪闪亮的");
    }

 这个时候bling就会报错

3.被final修饰的类不可以被继承

【在Diamods class前面加上final】

此时的PinkDiamods就会报错

现在前面的内没有加final就可以继承

加上final后就不可以继承了，final修饰的类就是最终的类

抽象

抽象：现实中不存在的东西
在Java中就表示：只声明，不实现

强制规定：在一个类中如果方法是抽象方法那么类也必须是抽象类
    抽象类的特点：
            1.抽象类不可以创建对象
            2.抽象类的子类必须重写父类中的抽象方法。否则，子类必须也是抽象类。

通过抽象类可以强制的要求子类中必须有那些方法【相当于规范作用】

抽象类中可以有正常的方法

创建一个Animal class

//由于强制规定所以也需要在类中加入abstract【类中有抽象方法那么类也必须是抽象类】
public abstract class Animal {

    //现在在方法中加上abstract 就表示抽象方法。
    //【注：抽象方法没有方法体此处直接在方法后加上分号就可以】
    public abstract void eat();
    //因为动物有很多而且进食方式、吃的东西的类型都不一样，所以不能进行定义。即使定义也只能笼统的定义

 抽象类的特点：

         1.抽象类不可以创建对象  

         2.抽象类的子类必须重写父类中的抽象方法。否则，子类必须也是抽象类。

创建class Cat 

public class Cat extends Animal{
    //继承过来了之后就相当于也是抽象类
    //此时就需要重写父类中的抽象方法。

    //public void eat();

    public void eat(){
        System.out.println("猫咪吃小鱼");
    }
}

 通过抽象类可以强制的要求子类中必须有那些方法

【相当于规范作用】

再写一个run方法

//现在加上方法run();,如果在Cat子类中不加，就会报错
    public abstract void run();

所以现在Cat中就也需要加上run方法

public void run(){
        System.out.println("比起跑猫咪的d跳力更好");
    }

写一个场景

//创建场景

public class Client {
    public static void main(String[] args) {
//        Cat cat=new Cat();
        //抽象类也有多态性
        Animal cat = new Cat();
        cat.eat();
        cat.run();

        //抽象类不可以创建对象
        //Animal ani=new Animal();//会报错，Animal()是抽象的不能被实例化
    }
}

 抽象类中可以有正常的方法

//抽象类中可以有正常的方法，不一定全是抽象方法
    public void semll(){
        System.out.println("笑一笑，十年少");
    }

 

接口

接口：
接口实际上是一种特殊的抽象类
接口中所有的方法都是抽象方法
接口使用interface来声明

注：能继承接口的只能是接口
【接口和类只能是实现关系（implement）】
实现关系和继承关系差不多
只是接口是：implements
继承是：extends

注意：类只能单继承【一个类只能继承一个父类】，接口支持多实现。

接口同样具有多态性

接口可以把很多不相关的内容进行整合

特点：
    1.接口中所有的方法都是抽象方法，都是公开的
    2.接口中所有的变量都是全局静态常量

创建一个class Valuable

接口使用interface来声明,这里就表示已经不是类了

public interface Valuable {//接口使用interface来声明,这里就表示已经不是类了

    //一定注意接口中所有的方法都是抽象方法,一定不可以有正常的方法
    public abstract void getMoney();
    //前面灰色：可以省略
    //abstract【因为接口中的所有方法都是抽象方法，所以都是一样的就可以省略】
    // public【接口中所有内容都是公开的公共的】
}

能继承接口的只能是接口 

 创建Gold

【类只能实现接口不能继承接口，所以下面写extends会报错】

实现关系和继承关系差不多
只是接口是：implements
继承是：extends

public class Gold implements Valuable {

    //必须要实现抽象方法（相当于继承中的重写）
    public void getMoney(){
        System.out.println("黄金很值钱，你可以用黄金去换钱");
    }
}

创建Test类去实现

public class Test {
    public static void main(String[] args) {
        //Gold g= new Gold();
        //因为接口和类只有[接口是：implements继承是：extends]不同，所以这里的金子也可以从Valuable的角度去看
        //接口也具有多态性
        Valuable g= new Gold();
        g.getMoney();
}

类只能单继承【一个类只能继承一个父类】，接口支持多实现。

创建接口Protectable并写出方法cang

public interface Protectable {
    public void cang();
}

创建class Animal并写出方法吃

public class Animal {
    public void eat(){
        System.out.println("动物会吃东西");
    }
}

创建class Panda

//类可以继承一个类，实现多接口【接口方法重写】
public class Pander extends Animal implements Valuable,Protectable{

    //下面的使用【右键-->Generate-->Override Methods-->选中需要的即可】
    @Override//@Override表示这个方法是重写的
    public void eat() {
        System.out.println("熊猫喜欢吃竹子");
    }

    @Override
    public void cang() {
        System.out.println("熊猫喜欢藏在竹林中");
    }

    @Override
    public void getMoney() {
        System.out.println("熊猫是中国国宝，超级值钱");
    }
}

测试一下：

public class Test {
    public static void main(String[] args) {

        Pander pander=new Pander();
        Animal animal=new Pander();//向上转型
        Valuable valuable=new Pander();//向上转型
        Protectable protectable=new Pander();//向上转型

        //站在Pander看
//        pander.eat();
//        pander.cang();
//        pander.getMoney();

        //站在Animal看
        //这里会发现，Animal中没有
        animal.eat();
        //站在动物的角度就只有吃，所以cang和getMoney没有
//        animal.cang();
//        animal.getMoney();

        //站在Valuable只有getMoney
        valuable.getMoney();
        //站在Protectable只有cang
        protectable.cang();
}

接口中所有的变量都是全局静态常量

public interface Valuable {//接口使用interface来声明,这里就表示已经不是类了

    public static final int money=100;//【前面public static final默认存在】
}

 测试

public class Test {
    public static void main(String[] args) {

//        Valuable.money=10; //全局静态常量不可变
//        但是可以打印出来
        System.out.println(Valuable.money);//出来的值就是前面所赋的值
    }
}

 有关接口的小练习 

创建IDAO

public interface IDAO {

    void connect();//连接
    void add();//增
    void del();//删
    void upd();//改
    void sel();//查
}

 创建MysqlDao

public class MysqlDao extends AbstractDao{

    @Override
    public void connect() {
        System.out.println("MySQL的连接");
    }

    @Override
    public void add() {
        System.out.println("MySQL的增加");
    }

    @Override
    public void del() {
        System.out.println("MySQL的删除");
    }

    @Override
    public void upd() {
        System.out.println("MySQL的修 改");
    }

    @Override
    public void sel() {
        System.out.println("MySQL的查找");
    }
}

创建OraclDao

public class OraclDao extends AbstractDao{
    @Override
    public void connect() {
        System.out.println("Oracle的连接");
    }

    @Override
    public void add() {
        System.out.println("Oracle的增加");
    }

    @Override
    public void del() {
        System.out.println("Oracle的删除");
    }

    @Override
    public void upd() {
        System.out.println("Oracle的修改");
    }

    @Override
    public void sel() {
        System.out.println("Oracle的查找");
    }
}

 由于MysqlDao和OraclDao中重复的太多了

所以现在创建AbstractDao

不需要在里面写connect是因为连接的不一样

//这里需要是抽象的：不想全部实现[连接MySQL或者是Oracle是不确定的。]

public abstract class AbstractDao implements IDAO{

    //void connect();

    @Override
    public void add() {
        System.out.println("增加");
    }

    @Override
    public void del() {
        System.out.println("删除");
    }

    @Override
    public void upd() {
        System.out.println("修改");
    }

    @Override
    public void sel() {
        System.out.println("查找");
    }
}

由于MySsqlDao和OracleDao之间重复的太多了，所以现在创建AbstractDao,在其中写出重复的部分。

然后对 MysqlDao和OraclDao进行修改

 MysqlDao

public class MysqlDao extends AbstractDao{

    //因为有了AbstractDao，所以现在可以将MysqlDao的MysqlDao改成extends 然后继承AbstractDao。
    //此时，下面重复的部分就可以删除了

    @Override
    public void connect() {
        System.out.println("MySQL的连接");
    }
}

 OraclDao

//与MysqlDao进行相同 *** 作

public class OraclDao extends AbstractDao{
    @Override
    public void connect() {
        System.out.println("Oracle的连接");
    }
}

测试

import java.util.Scanner;

public class Client {
    public static void main(String[] args) {
        System.out.println("请问你要连接的数据库是哪一个？？？【1.MySQL  2.Oracle】");
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();

        IDAO dao;
        if (n == 1) {
//            IDAO dao = new MysqlDao();
            dao = new MysqlDao();
        } else {
//            IDAO dao = new OraclDao();
            dao = new OraclDao();
        }

        //此时在外部用dao是用不了的，原因是dao在if内部【所以现在在if外面进行声明】
        dao.connect();
        dao.add();
        dao.del();
        dao.upd();
        dao.sel();
    }
}

运行结果 

 

 慢慢理解世界，慢慢更新自己！！！每天都要加油啊，小鲁✌