JAVA学习笔记——第十一章枚举和注解

一、引出枚举类

1.先看一个需求demo

package com.hspedu.enum_;public class Enumration01 {public static void main(String[] args) {Season Spring = new Season("春天", "温暖");Season Summer = new Season("夏天", "炎热");Season Autumn = new Season("秋天", "潮湿");Season Winter = new Season("冬天", "寒冷");//对于季节来说，他的对象是固定的四个不会有更多，如果按照这个设计类的思路，不能体现季节是固定的四个对象。// 因此这样的设计不好Autumn.setName("XXX");Autumn.setDesc("hahaha");//可以引出枚举类，把具体的对象一个一个列举出来的类//称为枚举类}
}class Season {private String name;private String desc;//描述public Season(String name, String desc) {this.name = name;this.desc = desc;}public String getDesc() {return desc;}public void setDesc(String desc) {this.desc = desc;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}

2.创建Season对象有如下的特点：

1）.季节的值是有限的几个值（spring，summer，autumn。wiinter）

2）.只读，不需要修改

3.解决方案-枚举

1）枚举对应英文enumeration

2）枚举是一组常量的集合

3）枚举是一种特殊的类，里面只包含一组有限的特定的对象

4.枚举的两种实现方式

1.自定义类实现枚举

package com.hspedu.enum_;public class Enumration02 {public static void main(String[] args) {System.out.println(Season.SPRING);}
}
//演示自定义枚举实现
//1.构造器私有化，防止直接被new出来
//2.把setXXX相关方法去掉，防止属性被修改
//3.在Season内部，直接创建固定的对象
//4.可以加一个final,final+static可以跳过类加载，调用final+ static的变量，你不可能去修改，可以不需要类加载，底层优化，避免了类加载
//补充：这里出现了误会，去看了前面的final关键字。其实这里并没有跳过类加载，因为它new了一定会进行类加载，这里只是想说明常量不能修改
class Season {private String name;private String desc;//描述//定义了四个对象public final static Season SPRING = new Season("春天","温暖");//常量必须大写规范public final static Season SUMMEE = new Season("夏天","炎热");public final static Season AUTUMN = new Season("秋天","潮湿");public final static Season WINTER = new Season("冬天","寒冷");private Season(String name, String desc) {this.name = name;this.desc = desc;}public String getDesc() {return desc;}public String getName() {return name;}@Overridepublic String toString() {return "Season{" +"name='" + name + '\'' +", desc='" + desc + '\'' +'}';}
}

2. 使用关键字enum实现类加载

package com.hspedu.enum_;public class Enumeration3 {public static void main(String[] args) {System.out.println(Season2.SPRING);System.out.println(Season2.SUMMER);}
}
//演示关键字实现枚举
enum Season2 {//定义了四个对象
//    public final static Season2 SPRING = new Season2("春天","温暖");//常量必须大写规范
//    public final static Season2 SUMMEE = new Season2("夏天","炎热");
//    public final static Season2 AUTUMN = new Season2("秋天","潮湿");
//    public final static Season2 WINTER = new Season2("冬天","寒冷");
//如果使用enum来实现枚举类//1.使用关键字替代class//2.public final static Season2 SPRING = new Season2("春天","温暖");直接使用    SPRING("春天","温暖");//其实格式就是常量名（SPRING）+传给构造器的参数（("春天","温暖")）//3.如果有多个常量（对象），使用逗号间隔即可//4.如果使用enum实现枚举。要求定义的常量对象写在最前面SPRING("春天","温暖"),Winter("冬天","寒冷"),SUMMER("夏天","炎热"),AUTUMN("秋天","潮湿");private String name;private String desc;//描述private Season2(String name, String desc) {this.name = name;this.desc = desc;}public String getDesc() {return desc;}public String getName() {return name;}@Overridepublic String toString() {return "Season{" +"name='" + name + '\'' +", desc='" + desc + '\'' +'}';}
}

5.enum关键字实现枚举-快速入门

对于1.，使用javap来证明 除了继承以外往下看都是public staitc final ，还有一些隐藏的属性啥的

对于3：如果调用无参构造器，创建常量对象，则可以省略()

what,SPRING("春天", "温暖"), Winter("冬天", "寒冷"), SUMMER("夏天", "炎热"), AUTUMN("秋天", "潮湿");//看上面如果调用无参构造器，创建常量对象，则可以省略()private String name;private String desc;//描述private Season2(){}private Season2(String name, String desc) {this.name = name;this.desc = desc;}

6.课堂练习

这个是对的，这里其实就是调用了Gender这个类的无参构造器，因为在这个类里面没有写其他的构造器，所以默认的无参构造器是存在的。

这里要考虑，这个BOY默认是public static final修饰的，static是类成员

第三行其实就是输出Gender2的tostring方法，但是它没有只能向上找分类Enum，Enum中（源码）的注释说了这个name就是enum常量的名称 ，所以第三行返回的就是BOY

且static说明这个BOY是一个静态对象，所以只有一个地址所以最后是true，其实感觉和静态关系也不大，本来就是同一个对象的两个引用指向它

7.java_Enum常用方法

package com.hspedu.enum_;/** @author SHOWY*/public class Enummethod03 {public static void main(String[] args) {//使用Season2枚举类来演示各种方法Season2 autumn = Season2.AUTUMN;//输出枚举对象的名称System.out.println(autumn.name());//输出的是该枚举对象的次序（第几个编号从0开始），后面可以用这个作比较System.out.println(autumn.ordinal());//返回的是Seasons2的数组，含有定义的所有枚举对象Season2[] values = Season2.values();//遍历取出枚举对象for (Season2 season : values) {//增强for循环System.out.println(season);}//valuesof把字符串转成枚举对象，要求字符串必须为已有的常量名//执行流程根据输入的名称到Season2的枚举对象查找，如果找到返回，如果没有报错Season2 autumn1 = Season2.valueOf("AUTUMN");System.out.println("autunmn1" + autumn1);System.out.println(autumn1 ==autumn);//compareto比较两个枚举常量，就是比较编号//就是把Season2.AUTUMN和Season2.SUMMER枚举对象的编号比较，发现其实是两个编号的差值System.out.println(Season2.AUTUMN.compareTo(Season2.SUMMER));}
}

8.java_Enum课堂练习

package com.hspedu.enum_;/** @author SHOWY*/import java.time.temporal.WeekFields;public class EnumExercise2 {public static void main(String[] args) {Week week[] = Week.values();System.out.println("所有星期的信息如下");for(Week w: week){System.out.println(w);}}
}enum Week{//创建week枚举对象MONDAY("星期一"),   TUESDAY("星期二"),   WEDNESDAY("星期三"),   THURSDAY("星期四"),   FRIDAY("星期五"),SATURDAY("星期六"),   SUNDAY("星期日");private String name;private Week(String name) {this.name = name;}@Overridepublic String toString() {return name;}
}

9.enum实现接口

二、注解

1.注解的理解

2.Java_Override注解

1.介绍

2.使用说明（总结）

3.Java_Deprecated注解

package com.hepedu.deprecated;/** @author SHOWY*/public class deprecated
{public static void main(String[] args) {A a = new A();a.hi();}
}
//1.@Deprecated修饰某个元素，表示该元素
//2.不推荐使用但是能用
//3.可以修饰方法、类、包、参数等等
//4.可以做版本升级过渡使用
@Deprecated
class A{public int n1 = 10;@Deprecatedpublic void hi(){System.out.println("hi");}
}

4.Java_SuppressWarnings注解

当我们不希望看到这些警告的时候，可以用SuppressWarnings注解来抑制这个警告信息

package com.hepedu.deprecated;/** @author SHOWY*/import java.util.ArrayList;
import java.util.List;public class SuppressWarnings {//1.当我们不希望看到这些警告的时候，可以用SuppressWarnings注解来抑制这个警告信息//2.在("")中可以写入你希望抑制的警告信息，直接给个all就行//3.关于SuppressWarnings的作用范围和放置的位置相关，比如放置//在main方法，那么抑制警告的范围就是main，也可以直接放在类上//4.看源码可以看见有一个 String[] value();说明该注解类可以设置一个数组@java.lang.SuppressWarnings("all")public static void main(String[] args) {List list = new ArrayList();list.add("A");list.add("B");list.add("C");list.add("D");int i;System.out.println(list.get(1));}
}

5.四种元注解

1.基本介绍

2.Retention注解

2.Target注解

3.Documented注解

形成文档的时候能保留

4.Inherited注解

注解具有继承性

三、练习

3.1 练习1

color是静态的上来就有一个空间，而静态static只在类加载的时候执行，所以在new c1的时候这个color不再变了，所以答案是9.0,red 100.0,red

3.2 练习2

(简单，跟着步骤写就行)

package com.test;/** @author SHOWY*/public class lianxi2 {
}
class Frock{private static int currentNum = 100000;private int serialNumber;public Frock() {serialNumber = getNextNum();}public int getSerialNumber() {return serialNumber;}public static int getNextNum(){currentNum +=  100;return currentNum;}}
class TestFrock{public static void main(String[] args) {System.out.println(Frock.getNextNum());//100100System.out.println(Frock.getNextNum());//100200Frock frock = new Frock();//100300Frock frock1 = new Frock();//100400Frock frock2 = new Frock();//100500System.out.println(frock.getSerialNumber());System.out.println(frock1.getSerialNumber());System.out.println(frock2.getSerialNumber());}
}

3.3 练习3

有点简单，就是有一个方法事abstract的，记得给这个类也是抽象类

package com.test;/** @author SHOWY*/public class liaxi3 {public static void main(String[] args) {Animal cat = new Cat();Animal dog = new Dog();cat.shout();dog.shout();}
}abstract class Animal{//抽象方法所以事抽象类public abstract void shout();
}class Cat extends Animal{@Overridepublic void shout() {System.out.println("小猫喵喵叫");}
}
class Dog extends Animal{@Overridepublic void shout(){System.out.println("小狗汪汪叫");}
}

3.4 练习4(很重要匿名内部类)

package com.test;/** @author SHOWY*/public class lianxi4 {public static void main(String[] args) {Cellphone cellphone = new Cellphone();cellphone.testwork(new Icalculate() {@Overridepublic double work(double n1, double n2) {return n1 + n2;}},2,3);cellphone.testwork(new Icalculate() {@Overridepublic double work(double n1, double n2) {return n1 * n2;}},3,4);}
}interface Icalculate{public double work(double n1,double n2);
}
class Cellphone{//当我们调用testWork方法时，直接传入了一个实现ICalculate的接口的匿名内部类，该匿名内部类可以灵活实现work方法完成不同的计算任务public void testwork(Icalculate icalculate, double n1,double n2){double result = icalculate.work(n1,n2);System.out.println("计算后的结果是" + result);}
}

3.5 练习5

package com.test;/** @author SHOWY*/public class lianxi5 {
}
class A {private String name = "cpy";public void f1() {class B {//这个类在方法体中，局部内部类private final String name = "gzh";public void show() {System.out.println("NAME" + name +"外部类的name" + A.this.name);
//重名了如果要调用外部类的私有变量就类.this.属性名来指定}}}
}

3.6 练习6（很难）

这道题还是有点难度大的，乱乱的

值得注意的点，比如在创建交通工具工厂类的时候，后续不需要创建对象，只需要加方法，所以设置为static，然后为了马是同一只马，也做了操作

//VehiclesFactory
package com.test;/** @author SHOWY*/public class VehiclesFactory {private static Horse  horse = new Horse();private VehiclesFactory() {}//防止创建对象//创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat//这里将方法做成static比较方便，不需要创建对象//为了船每次得到新的，马是老的同一只public static Horse getHorse(){return horse;}public static Boat getBoat(){return new Boat();}}//Horse
package com.test;/** @author SHOWY*/public class Horse implements Vehicles{@Overridepublic void work() {System.out.println("一般情况下使用马儿前进");}
}
//Boat
package com.test;/** @author SHOWY*/public class Boat implements Vehicles{@Overridepublic void work() {System.out.println("过河的时候使用小船");}
}

//Interface Vehicles  
package com.test;/** @author SHOWY*/public interface Vehicles {public void work();}

//Person
package com.test;/** @author SHOWY*/public class Person {private String name;private Vehicles vehicles;//接口当属性第一次见！public Person(String name, Vehicles vehicles) {this.name = name;this.vehicles = vehicles;}//实例化Person对象“唐僧”，要求一般情况下用horse作为交通工具，遇到大河时用Boat作为交通工具//这里涉及一个编程思路，就是可以把具体的要求封装成方法//先得到船//思考一个问题，如果不浪费在构建对象的时候，传入的交通工具对象public void passRiver() {
//        Boat boat = VehiclesFactory.getBoat();
//        boat.work();if(!(vehicles instanceof Boat)){vehicles = VehiclesFactory.getBoat();}vehicles.work();}public void common(){
//        Horse horse = VehiclesFactory.getHorse();
//        horse.work();if(!(vehicles instanceof Horse)){vehicles = VehiclesFactory.getHorse();}vehicles.work();}
}

//主函数
package com.test;/** @author SHOWY*/public class lianxi6 {
public static void main(String[] args) {Person tang =  new Person("唐僧",new Horse());tang.common();tang.passRiver();
}
}

补充：他要过一次火焰山

这时候可以用到匿名内部类，假设他就过一次火焰山，除了添加firehill类以外

package com.test;/** @author SHOWY*/public class Person {private String name;private Vehicles vehicles;//接口当属性第一次见！public Person(String name, Vehicles vehicles) {this.name = name;this.vehicles = vehicles;}//实例化Person对象“唐僧”，要求一般情况下用horse作为交通工具，遇到大河时用Boat作为交通工具//这里涉及一个编程思路，就是可以把具体的要求封装成方法//先得到船//思考一个问题，如果不浪费在构建对象的时候，传入的交通工具对象public void passRiver() {
//        Boat boat = VehiclesFactory.getBoat();
//        boat.work();if(!(vehicles instanceof Boat)){vehicles = VehiclesFactory.getBoat();}vehicles.work();}public void common(){
//        Horse horse = VehiclesFactory.getHorse();
//        horse.work();if(!(vehicles instanceof Horse)){vehicles = VehiclesFactory.getHorse();}vehicles.work();}public void testwork(Vehicles vehicles){vehicles = VehiclesFactory.getfirehill();//搞到vehicles以后调用workvehicles.work();}
}

package com.test;/** @author SHOWY*/public class lianxi6 {
public static void main(String[] args) {Person tang =  new Person("唐僧",new Horse());tang.common();tang.passRiver();tang.testwork(new Vehicles() {@Overridepublic void work() {System.out.println("火焰山坐飞机走了");}});
}
}

3.7 练习7（成员内部类）

这个题就是一个成员内部类，关键点在于在这类中写一个返回Air对象的方法！！！

package com.test;/** @author SHOWY*/public class lianxi7 {public static void main(String[] args) {//实例化不同的对象Car car = new Car(60);car.getAir().flow();Car car1 = new Car(-1);car1.getAir().flow();}}
class Car{private double temperature;public Car(double temperature) {this.temperature = 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("温度正常，关系空调");}}}//提供一个方法，返回Air对象public Air getAir(){return new Air();}
}

3.8 练习8（好题）

重点在switch中枚举对象的匹配

package com.test;/** @author SHOWY*/public class lianxi8
{public static void main(String[] args){//演示枚举值得switch使用，switch中放入枚举对象,在case中直接写在枚举类中定义的枚举对象即可Color green = Color.GREEN;green.show();switch (green){case RED:System.out.println("匹配黄色");break;case BLACK:System.out.println("匹配到黑色");break;default:System.out.println("没有匹配到");}
}}
interface Myinterface{public void show();
}
enum Color implements Myinterface{RED(255,0,0),BLUE(0,0,255),BLACK(0,0,0),YELLOW(255,255,0),GREEN(0,255,0);private int redCalue;private int greenCalue;private int blueCalue;Color(int redCalue, int greenCalue, int blueCalue) {this.redCalue = redCalue;this.greenCalue = greenCalue;this.blueCalue = blueCalue;}@Overridepublic void show() {System.out.println("属性值为" + redCalue + "," + greenCalue + "," + blueCalue);}
}