Java学习day12--转型、抽象类、接口

1、转型

标准 : 对应类型的数据赋值给对应类型变量

int i = 1;

基本数据类型的类型转换：

• 自动类型提升 : 小--->大

    long l = i;

• 强制类型转换 : 大--->小,有可能造成损失精度(不精确)-->需要手动进行强转

    int m = (int)l;

转型 , 引用数据类型的类型转换:

父类-->“大类型”

子类-->“小类型”

当前后类型不一致 :

向上转型 : 小 --> 大 -->多态

    Person p = new Student();

向下转型 : 向下转型对象不变,引用从父类类型转为子类类型,就可以调用子类中所有的成员(子类新增)

    Student s = (Student)p;

java.lang.ClassCastException : 类型转换异常

instanceof:

• 引用 instanceof 类型 : 判断前面的引用是否是指向后面类型的对象或者子类对象对象,如果是返回true,不是返回false

• 用法：

引用 instanceof 类型

• 使用instanceof运算符在转型之前先判断,再转型,避免类型转换异常的出现

 Fu f = new Zi();//父类引用指向子类对象
        //向下转型
        if(f instanceof Zi2){  //判断f的指向是否为Zi2类型的对象
            Zi2 zi = (Zi2)f;
            zi.test();
        }else if(f instanceof Zi){//判断f的指向是否为Zi类型的对象
            Zi zi = (Zi)f;
            zi.test();
        }

2、abstract类（抽象类）

• 被abstract修饰的类-->抽象类

• 被abstract修饰的方法-->抽象方法

特点：没有方法体

必须定义在抽象类中

注意 :

1.抽象类不能实例化

2.抽象类中可以定义 : 属性,构造器,功能,抽象方法...

3.抽象方法必须定义在抽象类中(接口)

4.抽象方法使用之前必须被重写

5.抽象类需要根据具体子类对象进行使用 :

具体子类 : 重写所有的抽象方法 + 按需新增

抽象子类 : 按需重写 + 按需新增

6.abstract不能与private,static,final与native一起使用

7.多态 : 类的多态,抽象类的多态,接口多态

abstract class Develop{
    //抽象方法
    public abstract void work();
    public abstract void sleep();
    //成员方法
    public void test(){
        System.out.println("成员方法");
    }
}

//Java类继承抽象类
class Java extends Develop{

    @Override
    public void work() {
        System.out.println("服务器端开发");
    }

    @Override
    public void sleep() {
        System.out.println("边敲代码边睡觉...");
    }

    //新增方法
    public void smile(){
        System.out.println("嘻嘻哈哈");
    }
}

//抽象子类
abstract class Web extends Develop{

    @Override
    public void work() {

    }
    //public abstract void sleep();

    //新增方法....
}

//具体子类
class Demo extends Web{

    @Override
    public void sleep() {

    }
    //新增方法.....
}

3、接口

如何定义接口 :

使用interface定义接口,使用class定义类

接口 :

• 特殊的抽象类

• 一般定义为抽象功能的集合

• 类只能单继承,接口可以多实现

• 提高代码复用性

• 接口定义开发规范

• 实现解耦(降低耦合度)

• jdk1.7之后

公共的静态的常量 : 默认被public static final ，可省略不写

公共的抽象的方法 : 默认被public abstract ，可省略不写

public class InterfaceTest implements Inter{
    //接口只能被实现，不能实例化，接口可以继承多个接口，一个类可以实现多个接口

    @Override
     public void print(){};
}
interface Inter{

    //接口中变量默认被public static final 修饰为常量
    //接口中方法，默认被public abstract修饰为抽象方法，该方法没有方法体
    public static final int SINGLE = 1;
    public abstract void print();
}

注意 :

• 接口不能实例化

• 使用 implements实现接口,使用extends继承父类

• 接口使用 : 通过具体的实现类对象调用

具体实现类 : 重写所有的抽象方法 + 按需新增

抽象实现类 : 按需重写 + 按需新增

• 类只能单继承,接口可以多实现

• 如果一个类又要继承父类,又要实现接口,必须先继承后实现

• 类与类之间 ： 只能单继承 而接口与接口之间 ： 可以多继承

class A extends D implements B,C{ // A类继承了D，实现了B和C两个接口  
}

• 类与接口之间 ： 只能类实现接口，可以多实现

interface A extends B,C{// 接口A继承了B和C两个接口 所有实现接口A的类必须要重写A、B、C中所有的抽象方法   
}

• 接口的实现与类的继承 :

继承一个父类,继承了父类的成员,有权使用父类的成员,拿过来直接用,极个别的不满意,可以重写

实现一个接口,就拥有了接口中定义的抽象功能,必须先重写接口中全部方法,为抽象方法定义方法体,然后才能使用

重写规则:

1: 存在继承关系或者实现关系

2：定义方法：

必须同名

修饰符： 子类的修饰符 >= 父类的修饰符 （可见性）

返回值： 子类的返回值 <= 父类的返回值 （引用类型的父子关系）

参数列表：子类的参数列表 == 父类的参数列表

抛出的异常： 子类抛出的异常 <= 父类抛出的异常