接口+内部类+枚举+注解

我不会写代码njdjnssj

于 2025-04-27 21:23:27 发布

阅读量869

点赞数 37

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_51718998/article/details/147470341

版权

接口

接口不能被实例化，也就是 interface A{}；不能出现new A();

接口中所有方法是public方法，接口中抽象方法，可以不用abstract修饰，接口里面的修饰符有默认的三个public static final int a = 23;

一个类同时可以实现多个接口，class pig implements IB,IC{}

接口不能继承其他类，但是可以继承多个别的接口。

接口的修饰符只能是public和默认的，这点和类的修饰符一样。

实现接口VS继承类

继承的价值主要在于解决代码的服用性和可维护性。

接口的价值主要在于设计好的各种方法，让其他类去实现这些方法，更加的灵活。

当子类继承了父类就自动拥有父类的功能，如果子类需要扩展功能，可以通过实现接口的方式扩展，可以理解为实现接口是对java单继承的一种补充。

内部类

一个类的内部又完整的嵌套了另一个类结构，被嵌套的类称为内部类，嵌套的其他类称为外部类。内部类的最大特点是可以直接访问私有属性，并且可以体现类与类间的包含关系。基本语法：class Outer{ //外部类

class Inner{ //内部类

}

class Other{//外部其他类}

类的五大成员：属性、方法、构造器、代码块、内部类

定义在外部类局部位置上（比如方法内）：1）局部内部类（有类名） 2）匿名内部类（没有类名），匿名内部类即是一个类的定义，同时它本身也是一个对象。调用方法：

new A(){

@override

public void cry(){

sout;

}

}.cry();

或

A a = new A(){

@override

public void cry(){

sout;

};

a.cry();

}

定义在外部类的成员位置上：1）成员内部类（没用static修饰） 2）静态内部类（使用static修饰）

（1）局部内部类定义在方法中（2）作用域在方法体或者代码块中（3）本质仍然是一个类

package InnerClass;

public class InnerClassExercise02 {
    public static void main(String[] args) {
        CellPhone cellPhone = new CellPhone();
        cellPhone.alarmclock(new Bell(){
            @Override
            public void ring() {
                System.out.println("起床了~");
            }
        });

        cellPhone.alarmclock(new Bell() {
            @Override
            public void ring() {
                System.out.println("上课了~");
            }
        });
    }
}

interface Bell{
    void ring();//方法
}

class CellPhone{
    public void alarmclock(Bell bell){
        bell.ring();
    }
}

输出结果为5 5

枚举类

把具体的对象一个一个列举出来的类称为枚举类。一般不需要提供set方法，因为枚举类对象通常为只读，对枚举对象使用final+static共同修饰，实现底层优化。枚举对象名通常使用全部大写，枚举对象也可以有多个属性。

package com.edu.enum_;


public class Enumeration01 {
    public static void main(String[] args) {
        System.out.println(Season.AUTUMN);
    }
}
//演示定义枚举实现
class Season{
    private String name;
    private String desc;
    //定义了四个对象
    public static Season SPRING = new Season("春天","温暖");
    public static Season WINNER = new Season("冬天","寒冷");
    public static Season SUMMER = new Season("夏天","炎热");
    public static Season AUTUMN = new Season("秋天","凉爽");

    //1.将构造器私有化，目的防止直接new
    //2.去掉set相关方法，防止属性被修改
    //3.在season内部直接创建固定的对象
    private Season(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }

    @Override
    public String toString() {
        return "Season{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }

}

enum自动调用父类的toString方法。

增强for循环：依次从数组中取出数据赋给循环变量，如果去除完毕则退出for。

valueof：将字符串转换成枚举对象，要求字符串必须为已有的常量名，否则报异常。

compareTo：比较两个枚举常量，比较的就是编号

package com.edu.enum_;

public class EnumExercise02 {
    public static void main(String[] args) {
        Week[] weeks = Week.values();
        System.out.println("====所有星期的信息如下====");
        for(Week week:weeks){
            System.out.print(week);
        }
    }
}
enum Week{
    MONDAY("星期一"),TUESDAY("星期二"),WEDNESDAY("星期四"),
    FRIDAY("星期五"),SATURDAY("星期六"),SUNDAY("星期日");
    private String detail;

    private Week(String detail) {
        this.detail = detail;
    }

    public String getDetail() {
        return detail;
    }

    @Override
    public String toString() {
        return detail+"\n";
    }
}

枚举类不能继承或被继承，但是还是可以实现接口的。

注解

也称为元数据，用于修饰解释包、类、方法、属性、构造器、局部变量等数据信息。

@SuppressWarnings（{"all"}），SuppressWarnings可以用来抑制警告出现。

元注解的种类：1）Retention只能修饰一个Annotation，用于指定可以保留多长时间。

作业

输出结果为：9.0 red 100.0 red。 static对象只会在加载的时候执行一次

package com.edu.enum_;

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

    }
}
class Frock{
    private static int currentNum = 100000;
    private int serialNumber;

    public Frock() {
        this.serialNumber = getNextNum();
    }

    public int getSerialNumber() {
        return serialNumber;
    }

    public static int getNextNum(){
        currentNum += 100;
        return currentNum;
    }


}
class TsetFrock {
    public static void main(String[] args) {
//        System.out.println(Frock.getNextNum());
//        System.out.println(Frock.getNextNum());
        Frock frock = new Frock();
        Frock frock1 = new Frock();
        Frock frock2 = new Frock();
        System.out.println(frock.getSerialNumber());
        System.out.println(frock1.getSerialNumber());
        System.out.println(frock2.getSerialNumber());
    }
}

package com.edu.enum_;

public class Homewok03 {
    public static void main(String[] args) {
        Animal cat = new Cat();
        cat.shout();
        Animal dog = new Dog();
        dog.shout();
    }
}
abstract class Animal{
    public abstract void shout();

}
class Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("猫会喵喵叫~");
    }
}
class Dog extends Animal{
    @Override
    public void shout() {
        System.out.println("狗会汪汪叫~");
    }
}

package com.edu.enum_;

/**
 * @author JQY
 * @version 1.0
 */
public class Homework04 {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        cellphone.testWork(new Cal() {
            @Override
            public double work(double n1, double n2) {
                return n1+n2;
            }
        },10,8);
    }
}
interface Cal{//该方法在匿名内部类完成
    public double work(double n1,double n2);
}
class Cellphone{
    public void testWork(Cal cal,double n1,double n2){
        double result = cal.work(n1,n2);
        System.out.println("计算后的结果是="+result);
    }
}

package com.edu.enum_;

/**
 * @author JQY
 * @version 1.0
 */
public class Homework05 {
    public static void main(String[] args) {
        new A().f1();
    }
}
class A{
    public void f1(){

        class B{
            private final String name = "Tom";
            public void show(){
                System.out.println("name"+name);
            }
        }
        B b = new B();
        b.show();
    }
}

如果A类里也有一个同名的name，则可以用A.this.name来调用。

package com.edu.enum_;

/**
 * @author JQY
 * @version 1.0
 */
public class Homework06 {
    public static void main(String[] args) {
        Person tang = new Person("唐僧",new Horse());
        tang.common();
        tang.passRiver();
    }
}

interface Vehicles{
    public void work();
}

class Horse implements Vehicles{
    @Override
    public void work() {
        System.out.println("一般情况下 使用马儿前进");
    }
}
class Boat implements Vehicles{
    @Override
    public void work() {
        System.out.println("过河的时候 使用小船前进");
    }
}

class vehiFacity{
    //将方法做成static，这样比较方便
    public static Horse getHorse(){
        return new Horse();
    }
    public static Boat getBoat(){
        return new Boat();
    }
}

class Person{
    private String name;
    private Vehicles vehicles;

    public Person(String name, Vehicles vehicles) {
        this.name = name;
        this.vehicles = vehicles;
    }

    //把具体要求封装成方法
    public void passRiver(){

        if(!(vehicles instanceof Boat)){
            vehicles = vehiFacity.getBoat();
        }
        vehicles.work();
    }

    public void common(){
        if(!(vehicles instanceof Horse)){
            vehicles = vehiFacity.getHorse();
        }
        vehicles.work();
    }
}

package com.edu.enum_;

/**
 * @author JQY
 * @version 1.0
 */
public class Homework07 {
    public static void main(String[] args) {
        Car car = new Car(20);
        Car car1 = new Car(50);
        Car car2 = new Car(-1);
        car.getAir().flow();
        car1.getAir().flow();
        car2.getAir().flow();

    }
}
class Car{
    private double temperature;
    class Air{
        public void flow(){
            if(temperature>40){
                System.out.println(" 温度大于40 吹冷气");
            }else if(temperature<0){
                System.out.println(" 温度小于0度吹热气");
            }else{
                System.out.println(" 温度正常，关闭空调");
            }
        }
    }

    public Car(double temperature) {
        this.temperature = temperature;
    }

    public Air getAir(){
        return new Air();
    }
}

可以通过public Air getAir(){

return new Air();

}获得成员内部类

package com.edu.enum_;

/**
 * @author JQY
 * @version 1.0
 */
public class Homework08 {
    public static void main(String[] args) {
        Color green = Color.GREEN;
        green.show();

        switch (green){
            case YELLOW:
                System.out.println("匹配到黄色");
            case BLACK:
                System.out.println("匹配到黑色");
            case RED:
                System.out.println("匹配到红色");
            case BLUE:
                System.out.println("匹配到蓝色");
            case GREEN:
                System.out.println("匹配到绿色");
        }

    }
}
interface IA{
    public void show();
}
enum Color implements IA{
    RED(250,0,0),BLUE(0,0,255),
    BLACK(0,0,0),YELLOW(255,255,0),
    GREEN(0,255,0);
    private int redValue;
    private int greenValue;
    private int buleValue;

    Color(int redValue, int greenValue, int buleValue) {
        this.redValue = redValue;
        this.greenValue = greenValue;
        this.buleValue = buleValue;
    }


    @Override
    public void show() {
        System.out.println("属性值为："+redValue+","+greenValue+","
        +buleValue);
    }
}