【Java复习巩固 Day4】面向对象（下）

抽象类

抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法

抽象类体现的是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式

package day4;

public abstract class SpeedMeter {
    // 转速
    private double turnRate;

    public SpeedMeter() {

    }

    public abstract double getRadius();

    public void setTurnRate(double turnRate) {
        this.turnRate = turnRate;
    }
    // 计算速度
    public double getSpeed() {
        return Math.PI * 2 * getRadius() * turnRate;
    }
}

package day4;

public class CarSpeedMeter extends SpeedMeter{

    @Override
    public double getRadius() {
        return 0.28;
    }

    public static void main(String[] args) {
        CarSpeedMeter carSpeedMeter = new CarSpeedMeter();
        carSpeedMeter.setTurnRate(15);
        System.out.println(carSpeedMeter.getSpeed());
    }
}

接口

Java8对接口进行了改进，允许接口中定义默认方法，默认方法可以提供方法实现

[修饰符] interface 接口名 extends 父接口1, 父接口2... {
	零个到多个常量定义
	零个到多个抽象方法定义
	零个到多个内部类、接口、枚举的定义
	零个到多个默认方法或类方法的定义
}

package day4;

public interface Output {
    int MAX_CACHE_LINE = 50;
    void out();
    void getData();

    default void print(String ... strings) {
        for (String string : strings) {
            System.out.println(string);
        }
    }

    default void test() {
        System.out.println("默认的test()方法");
    }

    static String staticTest() {
        return "接口里的类方法";
    }
}

package day4;

public class OutputFieldTest {
    public static void main(String[] args) {
        System.out.println(Output.MAX_CACHE_LINE);
        System.out.println(Output.staticTest());
    }
}

Java8允许在接口中定义默认方法，默认方法必须使用default修饰
Java8允许在接口中定义类方法，类方法必须使用static修饰

接口的继承和类的继承不一样，接口可以多继承，即一个接口可以有多个直接父类接口

package day4;

interface interfaceA {
    int PROP_A = 5;
    void testA();
}

interface interfaceB {
    int PROP_B = 6;
    void testB();
}

interface interfaceC extends interfaceA, interfaceB {
    int PROP_C = 7;
    void testC();
}

public class InterfaceExtendsTest {
    public static void main(String[] args) {
        System.out.println(interfaceC.PROP_A);
        System.out.println(interfaceC.PROP_B);
        System.out.println(interfaceC.PROP_C);
    }
}

接口的主要用途

• 定义变量，也可以用于进行强制类型转换
• 调用接口中定义的常量
• 被其他类实现

一个类可以继承一个父类，并同时实现多个接口，implements部分必须放在extends部分之后
一个类实现了一个或多个接口，这个类必须完全实现这些接口里所定义的全部抽象方法；否则，该类将保留从父接口那里继承到的抽象方法，该类必须定义成抽象类

内部类

在某些情况下，会把一个类放在另一个类的内部定义，这个定义在其他类内部的类就被称为内部类

package day4;

public class Cow {
    private double weight;

    public Cow() {

    }

    public Cow(double weight) {
        this.weight = weight;
    }

    private class CowLeg {
        private double length;
        private String color;

        public CowLeg() {

        }

        public CowLeg(double length, String color) {
            this.color = color;
            this.length = length;
        }

        public double getLength() {
            return length;
        }

        public void setLength(double length) {
            this.length = length;
        }

        public String getColor() {
            return color;
        }

        public void setColor(String color) {
            this.color = color;
        }

        public void info() {
            System.out.println("color: " + color + ", length: " + length);
            System.out.println("weight: " + weight);
        }
    }
    public void test() {
        CowLeg cowLeg = new CowLeg(1.14, "red");
        cowLeg.info();
    }

    public static void main(String[] args) {
        Cow cow = new Cow(400);
        cow.test();
    }
}

根据静态成员不能访问非静态成员的规则，外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、实例等
不允许在外部类的静态成员中直接使用非静态内部类

package day4;

interface Product {
    double getPrice();

    String getName();
}

public class AnonymousTest {
    public void test(Product product) {
        System.out.println(product.getName() + ": " + product.getPrice());
    }

    public static void main(String[] args) {
        AnonymousTest anonymousTest = new AnonymousTest();
        anonymousTest.test(new Product() {
            @Override
            public double getPrice() {
                return 600.50;
            }

            @Override
            public String getName() {
                return "商品";
            }
        });
    }
}

匿名内部类不能是抽象类，因为系统在创建匿名内部类时，会立即创建匿名内部类的对象，因此不允许将匿名内部类定义成抽象类
匿名内部类不能定义构造器，由于匿名内部类没有类名，所以无法定义构造器，但匿名内部类可以定义初始化块，可以通过实例初始化块来完成构造器需要完成的事情

枚举类

实例有限且固定的类，在Java里被称为枚举类

package day4;

public enum  SeasonEnum {
    SPRING, SUMMER, FALL, WINTER;
}

package day4;

public class EnumTest {
    public void judge(SeasonEnum s) {
        switch (s) {
            case SPRING:
                System.out.println("春天");
                break;
            case SUMMER:
                System.out.println("夏天");
                break;
            case FALL:
                System.out.println("秋天");
                break;
            case WINTER:
                System.out.println("冬天");
                break;
        }
    }

    public static void main(String[] args) {
        EnumTest enumTest = new EnumTest();
        for (SeasonEnum s : SeasonEnum.values()) {
            System.out.println(s);
            enumTest.judge(s);
        }

    }
}

SPRING
春天
SUMMER
夏天
FALL
秋天
WINTER
冬天

Process finished with exit code 0

---

蒟蒻写博客不易，加之本人水平有限，写作仓促，错误和不足之处在所难免，谨请读者和各位大佬们批评指正。
如需转载，请署名作者并附上原文链接，蒟蒻非常感激
名称：虐猫人薛定谔
博客地址：https://blog.youkuaiyun.com/Deep___Learning