Java学习笔记——抽象类与接口

2021.12.11

一、抽象类的相关注意事项

1.定义一个抽象类，必须有子类、
2.且子类要覆写所有抽象类的abstract函数
3.抽象类对象的实例化可以利用对象多态性->son类向上转型的方式完成
4.利用"对象的多态性"，子类向上转型实例化Father
  ——这样调用@Override时执行的就是子类覆写的函数
5.抽象类最大的特点——无法自己实例化对象，通过"对象的多态性"向上转型实现
6.注意：
i.抽象类必须被继承，因此禁止用final修饰
ii.抽象类中可以定义成员属性&普通方法、子类实例话时会调用abstract类的构造函数
——若abstract类没有提供、则必须通过super（）形式调用指定参数的构造函数
7.抽象类中可以没有抽象方法、但仍然无法new对象
8.抽象类中可以提供static方法、并且该方法不受到抽象类实例话对象的影响**

abstract class Message{
    private String type;
    public abstract String getConnection();//抽象函数不需要写函数体{}

    public void setType(String type){
        this.type = type ;
    }

    public String getType(){
        return this.type;
    }
}

class Database extends Message
{
    @Override//覆写
    public String getConnection(){
        return super.getType();
    }
}


public class Abstract {
    public static void main(String[] args) {
        Message msg = new Database();
        msg.setType("China");
        System.out.println(msg.getConnection());
    }
}

二、包装类和数据转换

包装类：

1.对象型包装类（Object直接子类）：Boolean、Character
2.数值型包装类（Number直接子类）：Byte、Short、Integer、Long、Float、Double
3.数据装箱、拆箱：
    i.数据装箱：将基本数据类型保存到包装类中，利用包装类的构造方法完成
Integer类：public Integer (int value)
Double类： public  Double （double value）
Boolean类：public Boolean （boolean value）
     ii.数据拆箱：
数值类包装类已经由number类定义了拆箱操作
Boolean型：public boolean boolean value（）

public class Package_class {

    public static void main(String[] args) {

        Integer obj_1 = new Integer(10);//手动装箱操作：将int类型转换成为类的对象
        int x = obj_1.intValue();

       Double obj_2 = 20.2;//自动装箱操作，不关心构造方法了
        obj_2 += 10;//直接参与数值运算了
       double y = obj_2;//自动拆箱、相当于调用了doubleValue（）函数

/*
      1、Object类接收浮点数据类型
      2、浮点型默认为Double类，进行拆箱操作的时候首先需要将Object类"强制向下"转为Double类才可以正常拆箱

*/
        Object obj_3 = 100.0;    //double自动转型为Double，向上转型为Object
        double num = (double) obj_3; //向下强制转换为double

        /*
        关于Integer自动装箱的数值比较问题
        1。自动装箱后的数值是Integer的对象，不能直接和⚠️"自动装箱"的数比大小
        2。若两个Integer的对象想要判断是否相等，数值在-127～128，可以用"=="
        3。两个对象数值超过此范围，使用 a.equals(y) 返回true 或 false
        
        */
        Integer x1 = new Integer(20);//手动装箱
        Integer y1 = 20;//自动装箱
        Integer z1 = 20;
        int d  = 20;

        System.out.println( "x1 == y ："  + (x1 == y1) ); //false
        System.out.println( "z1 == y1 ：" + (z1 == y1));  //true
        System.out.println( "x1 == d ："+(x1 == d) ); //true
        System.out.println( "y1 == d ：" +(y1 == d) );//true

        int y2 = (int) y1; //Object向下强转成int类型
        System.out.println( "y2 == d :" +(y2 == d) );//true

        System.out.println( "x1.equals(y1) :" +(x1.equals(y1)));//用equals函数进行比较


        /*数据类型转换*/

        //将字符串变成int类型:Integer.parseInt();
        String str = "1234";
        int num_1 = Integer.parseInt(str);
        System.out.println( num_1 + num_1);

        //将字符串变成boolean类型
        System.out.println( "将字符串变成boolean类型:" );
        String strA = "true";
        String strB = "Hello JavaDemo";
        boolean flagA = Boolean.parseBoolean(strA);
        boolean flagB = Boolean.parseBoolean(strB);
        System.out.println( flagA ); //若是true则转换为true,其余情况全是false
        System.out.println( flagB );//false

        //基本数据类型转化为String类型：两种方法
        //1⃣️连接空字符串，但是会单独声明字符串常量，有垃圾产生
        int Num = 1000;
        String str_int = Num + "";
        System.out.println( str_int.length()  );

        //2⃣️利用valueOf()实现转换,更高效
        String str_valueof = String.valueOf(Num);
        System.out.println( str_valueof.length() );
    }

}

三、接口

接口：
1.接口属于一个特殊的类，使用interface定义
2.接口中可以包含"全局常量"、"抽象方法"（必须是public访问权限）
————、"default函数"、"static函数"
3.关于interface的使用原则：
  1⃣️接口需要被子类实现，子类利用implements关键字可以实现多个父接口
  2⃣️若子类不是abstract类、则一定要覆写子类中全部抽象函数
  3⃣️接口对象可以利用子类对象的"向上转型"进行实例化
4.关于extends、inplements关键字的顺序
  1⃣️子类可以继承父类实现父接口
  2⃣️如果出现混用，应该先继承、再接口
  3⃣️子类接口：❕可以同时有多个父接口，但每个子类只能继承一个类

 5.关于全局常量在接口中有简化版本（参见IMessage接口）
 1⃣️全局常量： public static final String Info = "Hello JavaDemo";
 简化为➡️  String  str = "   "；
 2⃣️抽象函数： public abstract String getInfo();
  简化为➡️  String getInfo（）

 6.接口可以多继承！！类（class）只能单继承
 7.接口中定义：default、static函数
 1⃣️接口中默认函数为抽象函数，可以用：public default boolean connect(){return true}
 2⃣️定义普通函数、普通函数可以被子类继承:但是接口的普通函数需要通过接口实例化对象调用
 3⃣️如果我们定义static函数、只需要接口名就可以调用了
 4⃣️public static IMessage getInstance(){return new MessageIpl}
 以上是在接口中定义static方法、可以直接实例化接口子类对象

//Interface.java
interface IMessage
{
    String Info = "Hello JavaDemo";//全局常量：public static final 省略
    String getInfo();//public abstract 省略

    /**定义一个可以被继承的普通函数 **/
    public default String fun1(){
        return "被继承的普通函数fun1";}

        /**定义一个可以被继承的static函数 **/
        public static IMessage getInstance() {
            return new MessageImpl()  ;
        }
    }



interface Ichannel{
    public abstract boolean connect(); //第二个接口、定义抽象方法
}

       /*让咱们来实现一下接口的多继吧！*/
interface I_service extends IMessage,Ichannel
       {
   public abstract String service();
       }

class MessageImpl implements  I_service,IMessage
{
    @Override
    public String service ( ){
        return "service 接口";
    }

    @Override
    public String getInfo(){//抽象函数覆写
        if(this.connect()){
            return "Successful!";
        }
        return "Default...";
    }
    @Override
    public boolean connect(){
        return false;


    }
}


public class Interface {
    public static void main(String[] args) {
        IMessage msg = new MessageImpl();//子类实例化父类接口、向上转型
        System.out.println( msg.getInfo() );
        System.out.println(msg.fun1());

        /*前面我们已经在IMessage里面定义了static类，
        现在咱们可以用"接口名"直接实例化对象*/

       IMessage msg_1 = IMessage.getInstance() ;//
        System.out.println( msg_1.getInfo() );

    }
}