抽象类

抽象类特点：

• 抽象类也是一个类
• 由abstract修饰的类为抽象类，由abstract修饰的方法为抽象方法
• 抽象方法必定存在于抽象类中，且抽象方法没有方法体
• 抽象类中有构造方法，但是不能创建实例
• 字段、方法都存在，可以通过子类进行调用
• 抽象类通常作为模板类，一个类继承了抽象类必须重写抽象方法

---

代码示例：

public class Test {
    public static void main(String[] args) {
        Rectangle rectangle = new Rectangle(1.5, 3.0);
        double area = rectangle.getArea();
        System.out.println(area);
    }
}

/**
 * 图形抽象类
 */
abstract class Graph{
    //面积抽象方法
    public abstract double getArea();
}

/**
 * 长方形
 */
class Rectangle extends Graph{
    //宽度
    private double width;
    //长度
    private double length;

    public Rectangle(double width,double length){
        this.width = width;
        this.length = length;
    }
    
    //重写抽象方法
    @Override
    public double getArea(){
        return width * length;
    }
}

运行结果

4.5
我是抽象类的方法
我是抽象类的字段

---

接口

接口是和类相似的一种结构，由 interface 关键字定义，主要用于定义一些规范，定义全局常量

注意事项： `

• 接口中的字段都是全局常量，默认由 public static final修饰，所以可通过接口名.字段名调用
• 接口中的方法都是抽象方法，默认由 public abstract 修饰,所以没有方法体
• 类和接口之间为实现( implements )关系，类实现接口必须重写接口中所有方法
• 接口和接口之间也是实现关系
• 抽象类也满足多态

---

接口的定义

代码示例：

/**
 * 定义接口
 */
interface A{
    //接口中的字段都是全局常量，默认由public static final修饰
    String CD = "成都";

    //接口中的方法都是抽象方法，默认由public abstract修饰
    void test();
}
class B implements A{
    //重写接口抽象方法，必须由
    @Override
    public void test(){
        System.out.println("重写接口方法");
    }
}

---

接口的继承与实现

类继承特点： 单继承、多重继承，没有显式继承关系，必定隐式继承Object类

接口继承与实现特点：

• 接口和接口之间可以多继承、多重继承
• 接口与类之间可以多实现
• 一个类同时继承了一个类并实现了接口，继承必须写在最前面

interface A{
}
interface C{
}

/**
 * 多继承
 */
interface D extends A,C{
}

/**
 * 多重继承
 */
interface E extends D{
}
/**
 * 多实现
 */
class B implements A,C{
}

/**
 * 继承和实现
 */
class F extends B implements A,C{
}
interface A{
}
interface C{
}

/**
 * 多继承
 */
interface D extends A,C{
}

/**
 * 多重继承
 */
interface E extends D{
}
/**
 * 多实现
 */
class B implements A,C{
}

/**
 * 继承和实现
 */
class F extends B implements A,C{
}

接口中的方法都是抽象方法，默认由public abstract修饰

---

内部类

内部类：就是类中的类

内部类方法调用：

public class InnerClassDemo {
    public static void main(String[] args) {
        //创建内部类对象,调用内部类方法
        new Outer().new Inner().test();
    }
}
/**
 * 外部类
 */
class Outer{
    /**
     * 内部类
     */
    class Inner{
        public void test(){
            System.out.println("哈哈哈哈");
        }
    }
}

静态内部类方法调用：

public class InnerClassDemo {
    public static void main(String[] args) {
        //调用静态内部类方法
        new Outer.Inner().test();
    }
}
/**
 * 外部类
 */
class Outer{
    /**
     * 内部类
     */
    static class Inner{
        public void test(){
            System.out.println("哈哈哈哈");
        }
    }
}

调用静态内部类的静态方法

public class InnerClassDemo {
    public static void main(String[] args) {
        //调用静态内部类静态方法
        Outer.Inner.test();
    }
}

/**
 * 外部类
 */
class Outer{
    /**
     * 内部类
     */
    static class Inner{
        public static void test(){
            System.out.println("哈哈哈哈");
        }
    }
}

---

匿名内部类

匿名内部类就是没有名字的内部类，一次性使用

定义匿名内部类语法：

new 接口名(){
	重写接口方法
};

代码示例：

public class InnerClassDemo {
    public static void main(String[] args) {
        //匿名内部类定义
        new Usb(){
            @Override
            public void test(){
                System.out.println("我是匿名内部类重写的方法");
            }
        }.test();
    }
}
interface Usb{
    void test();
}

运行结果：

我是匿名内部类重写的方法

---