package com.hspedu.enum_;
public class Enumeration01 {
public static void main(String[] args) {
Season spring = new Season("春天", "温暖");
Season winter = new Season("冬天", "寒冷");
Season summer = new Season("夏天", "炎热");
Season autumn = new Season("秋天", "凉爽");
autumn.setName("XXX");
autumn.setDesc("非常的热..");
//因为对于季节而已,他的对象(具体值),是固定的四个,不会有更多
//按照老师的这个设计类的思路,不能体现季节是固定的四个对象
//因此,这样的设计不好===> 枚举类[枚: 一个一个 举: 例举 , 即把具体的对象一个一个例举出来的类
// 就称为枚举类]
Season other = new Season("红天", "~~~");
}
}
class Season{
private String name;
private String desc;
public Season(String name, String desc) {
this.name = name;
this.desc = desc;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDesc() {
return desc;
}
public void setDesc(String desc) {
this.desc = desc;
}
}
创建 Season 对象有如下特点
package com.hspedu.enum_;
/**
* @author 林然
* @version 1.0
*/
public class Enumeration02 {
public static void main(String[] args) {
}
}
//演示自定义枚举实现
class Season01{
private String name;
private String desc;
//定义了四个对象, 固定.
public static final Season SPRING = new Season("春天", "温暖");
public static final Season WINTER = new Season("冬天", "寒冷");
public static final Season AUTUMN = new Season("秋天", "凉爽");
public static final Season SUMMER = new Season("夏天", "炎热");
//1. 将构造器私有化,目的防止 直接 new
//2. 去掉 setXxx 方法, 防止属性被修改
//3. 在 Season 内部,直接创建固定的对象
private Season01(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 "Season01{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}
进行自定义类实现枚举,有如下特点:
使用 enum 来实现前面的枚举案例,看下面演示,主要体会和自定义类实现枚举不同的地方
package com.hspedu.enum_;
/**
* @author 林然
* @version 1.0
*/
public class Enumeration03 {
public static void main(String[] args) {
System.out.println(Season02.AUTUMN);
System.out.println(Season02.SUMMER);
}
}
//演示使用 enum 关键字来实现枚举类
enum Season02{
//4. 如果使用 enum 来实现枚举,要求将定义常量对象,写在前面
SPRING("春天", "温暖"), WINTER("冬天", "寒冷"),
AUTUMN("秋天", "凉爽"), SUMMER("夏天", "炎热"),WHAT();//What()可以简写成WHAT
private String name;
private String desc;
//定义了四个对象, 固定.
// public static final Season SPRING = new Season("春天", "温暖");
// public static final Season WINTER = new Season("冬天", "寒冷");
// public static final Season AUTUMN = new Season("秋天", "凉爽");
// public static final Season SUMMER = new Season("夏天", "炎热");
//如果使用了 enum 来实现枚举类
//1. 使用关键字 enum 替代 class
//2. public static final Season SPRING = new Season("春天", "温暖") 直接使用
// SPRING("春天", "温暖") 解读 常量名(实参列表)
//3. 如果有多个常量(对象), 使用 ,号间隔即可
//4. 如果使用 enum 来实现枚举,要求将定义常量对象,写在前面
//5. 如果我们使用的是无参构造器,创建常量对象,则可以省略 ()
private Season02() {
}
private Season02(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 "Season01{" +
"name='" + name + '\'' +
", desc='" + desc + '\'' +
'}';
}
}
说明:使用关键字 enum 时,会隐式继承 Enum 类, 这样我们就可以使用 Enum 类相关的方法
package com.hspedu.enum_;
/**
* @author 林然
* @version 1.0
*/
public class EnumMethod {
public static void main(String[] args) {
//使用 Season2 枚举类,来演示各种方法
Season02 autumn = Season02.AUTUMN;
//输出枚举对象的名字
System.out.println(autumn.name());
//ordinal() 输出的是该枚举对象的次序/编号,从 0 开始编号
//AUTUMN 枚举对象是第三个,因此输出 2
System.out.println(autumn.ordinal());
//从反编译可以看出 values 方法,返回 Season2[]数组
//含有定义的所有枚举对象
Season02 [] values =Season02.values();
System.out.println("===遍历取出枚举对象(增强 for)====");
for (Season02 season: values) {//增强 for 循环
System.out.println(season);
}
//valueOf:将字符串转换成枚举对象,要求字符串必须
//为已有的常量名,否则报异常
//执行流程
//1. 根据你输入的 "AUTUMN" 到 Season2 的枚举对象去查找
//2. 如果找到了,就返回,如果没有找到,就报错
Season02 autumn1 = Season02.valueOf("AUTUMN");
System.out.println("autumn1="+autumn1);
//compareTo:比较两个枚举常量,比较的就是编号
//1. 就是把 Season2.AUTUMN 枚举对象的编号 和 Season2.SUMMER 枚举对象的编号比较
//2. 看看结果
/*
public final int compareTo(E o){
return self.ordinal - other.ordinal;
}
*/
System.out.println(Season02.AUTUMN.compareTo(Season02.SUMMER));
//补充了一个增强 for
// int[] nums = {1, 2, 9};
// //普通的 for 循环
// System.out.println("=====普通的 for=====");
// for (int i = 0; i < nums.length; i++) {
// System.out.println(nums[i]);
// }
// System.out.println("=====增强的 for=====");
// //执行流程是 依次从 nums 数组中取出数据,赋给 i, 如果取出完毕,则退出 for
// for(int i : nums) {
// System.out.println("i=" + i);
// }
}
}
package com.hspedu.enum_;
/**
* @author 林然
* @version 1.0
*/
public class EnumExercise02 {
public static void main(String[] args) {
Week [] weeks =Week.values();
System.out.println("===所有星期的信息如下===");
for(Week week :weeks){
System.out.println(week.getName());
}
}
}
enum Week{
MONDAY("星期一"),TUESDAY("星期二"), WEDNESDAY("星期三"),
THURSDAY("星期四"), FRIDAY("星期五"), SATURDAY("星期六"),
SUNDAY("星期天");
private String day_name;
Week(String day_name) {
this.day_name = day_name;
}
public String getName() {
return day_name;
}
}
package com.hspedu.enum_;
/**
* @author 林然
* @version 1.0
*/
public class EnumDetail {
public static void main(String[] args) {
Music.CLASSICMUSIC.playing();
}
}
class A{
}
//1.使用 enum 关键字后,就不能再继承其它类了,因为 enum 会隐式继承 Enum,而 Java 是单继承机制
//enum Season3 extends A {
//
//}
//2.enum 实现的枚举类,仍然是一个类,所以还是可以实现接口的
interface IPlaying {
public void playing();
}
enum Music implements IPlaying{
CLASSICMUSIC;
@Override
public void playing() {
System.out.println("播放好听的音乐...");
}
}
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Override_ {
public static void main(String[] args) {
}
}
class Father{//父类
public void fly(){
System.out.println("Father fly...");
}
public void say(){}
}
class Son extends Father {//子类
//1. @Override 注解放在 fly 方法上,表示子类的 fly 方法时重写了父类的 fly
//2. 这里如果没有写 @Override 还是重写了父类 fly
//3. 如果你写了@Override 注解,编译器就会去检查该方法是否真的重写了父类的
// 方法,如果的确重写了,则编译通过,如果没有构成重写,则编译错误
//4. 看看 @Override 的定义
// 解读: 如果发现 @interface 表示一个 注解类
/*
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.SOURCE)
public @interface Override {
}
*/
@Override //说明
public void fly() {
System.out.println("Son fly....");
}
@Override
public void say() {}
}
@Deprecated: 用于表示某个程序元素(类, 方法等)已过时 ,但是仍然可以使用
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Deprecated_ {
public static void main(String[] args) {
A a =new A();
a.hi();
}
}
//1. @Deprecated 修饰某个元素, 表示该元素已经过时
//2. 即不在推荐使用,但是仍然可以使用
//3. 查看 @Deprecated 注解类的源码
//4. 可以修饰方法,类,字段, 包, 参数 等等
//5. @Deprecated 可以做版本升级过渡使用
/*
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value={CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE})
public @interface Deprecated {
}
*/
@Deprecated
class A {
@Deprecated
public int n1 = 10;
@Deprecated
public void hi(){
}
}
@SuppressWarnings: 抑制编译器警告
package com.hspedu.annotation_;
import java.util.ArrayList;
import java.util.List;
/**
* @author 林然
* @version 1.0
*/
@SuppressWarnings({"rawtypes", "unchecked", "unused"})
public class SuppressWarnings_ {
//1. 当我们不希望看到这些警告的时候,可以使用 SuppressWarnings 注解来抑制警告信息
//2. 在{""} 中,可以写入你希望抑制(不显示)警告信息
//3. 可以指定的警告类型有
// all,抑制所有警告
// boxing,抑制与封装/拆装作业相关的警告
// //cast,抑制与强制转型作业相关的警告
// //dep-ann,抑制与淘汰注释相关的警告
// //deprecation,抑制与淘汰的相关警告
// //fallthrough,抑制与 switch 陈述式中遗漏 break 相关的警告
// //finally,抑制与未传回 finally 区块相关的警告
// //hiding,抑制与隐藏变数的区域变数相关的警告
// //incomplete-switch,抑制与 switch 陈述式(enum case)中遗漏项目相关的警告
// //javadoc,抑制与 javadoc 相关的警告
// //nls,抑制与非 nls 字串文字相关的警告
// //null,抑制与空值分析相关的警告
// //rawtypes,抑制与使用 raw 类型相关的警告
// //resource,抑制与使用 Closeable 类型的资源相关的警告
// //restriction,抑制与使用不建议或禁止参照相关的警告
// //serial,抑制与可序列化的类别遗漏 serialVersionUID 栏位相关的警告
// //static-access,抑制与静态存取不正确相关的警告
// //static-method,抑制与可能宣告为 static 的方法相关的警告
// //super,抑制与置换方法相关但不含 super 呼叫的警告
// //synthetic-access,抑制与内部类别的存取未最佳化相关的警告
// //sync-override,抑制因为置换同步方法而遗漏同步化的警告
// //unchecked,抑制与未检查的作业相关的警告
// //unqualified-field-access,抑制与栏位存取不合格相关的警告
// //unused,抑制与未用的程式码及停用的程式码相关的警告
//4. 关于 SuppressWarnings 作用范围是和你放置的位置相关
// 比如 @SuppressWarnings 放置在 main 方法,那么抑制警告的范围就是 main
// 通常我们可以放置具体的语句, 方法, 类
//5. 看看 @SuppressWarnings 源码
//(1) 放置的位置就是 TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE
//(2) 该注解类有数组 String[] values() 设置一个数组比如 {"rawtypes", "unchecked", "unused"}
/*
@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.SOURCE)
public @interface SuppressWarnings {
String[] value();
}
*/
public static void main(String[] args) {
List list = new ArrayList();
list.add("jack");
list.add("tom");
list.add("mary");
int i;
System.out.println(list.get(1));
}
}
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Homework02 {
public static void main(String[] args) {
}
}
class Frock{
private static int currentNum =100000;//衣服出厂序列号
private int serialNumber;
public static int getNextNum(){
currentNum=currentNum+100;
return currentNum;
}
public Frock() {
this.serialNumber = getNextNum();
}
public int getSerialNumber() {
return serialNumber;
}
public void setSerialNumber(int serialNumber) {
this.serialNumber = serialNumber;
}
}
class TestFrock{
public static void main(String[] args) {
System.out.println(Frock.getNextNum());//100100
System.out.println(Frock.getNextNum());//100200
Frock frock1 = new Frock();//100300
Frock frock2 = new Frock();
Frock frock3 = new Frock();
System.out.println(frock1.getSerialNumber());
System.out.println(frock2.getSerialNumber());
System.out.println(frock3.getSerialNumber());
}
}
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Homework03 {
public static void main(String[] args) {
Animal cat =new Cat();
cat.shout();
Animal dog =new Dog();
dog.shout();
}
}
abstract class Animal{
abstract void shout();
}
class Cat extends Animal{
@Override
void shout() {
System.out.println("猫会喵喵叫");
}
}
class Dog extends Animal{
@Override
void shout() {
System.out.println("狗会汪汪叫");
}
}
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Homework04 {
public static void main(String[] args) {
Cellphone cellphone =new Cellphone();
cellphone.testwork(new ICalculate() {
@Override
public double work(double n1, double n2) {
return n1+n2;
}
},10,29);
}
}
interface ICalculate{
//work方法是完成计算,但是题目没有具体要求
//方法具体完善交给匿名内部类
double work(double n1,double n2);
}
class Cellphone{
public void testwork(ICalculate iCalculate,double n1,double n2){
System.out.println("计算的结果是"+iCalculate.work(n1,n2));
}
}
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Homework05 {
public static void main(String[] args) {
AA aa =new AA("aa");
aa.f1();
}
}
class AA{
private String name;
public AA(String name) {
this.name = name;
}
public void f1(){
class B{
private final String name="BB";
void show(){
System.out.println("局部内部类的name"+name+"外部类的name"+AA.this.name);
}
}
B bb =new B();
bb.show();
}
}
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Homework06 {
public static void main(String[] args) {
Person p1 =new Person("唐僧",new Horse());
p1.common();//一般情况
p1.passRiver();//过河
}
}
interface Vehivles{
void work();
}
class Horse implements Vehivles{
@Override
public void work() {
System.out.println("Horse工作");
}
}
class Boat implements Vehivles{
@Override
public void work() {
System.out.println("Boat工作");
}
}
class VehiclesFactory{
//创建交通工具类,有两个方法分别获得交通工具Horse和Boat
//马始终是同一个
private static Horse horse=new Horse();//饿汉式
public static Horse getHorse(){
//return new Horse();
return horse;
}
public static Boat getBoat(){
return new Boat();
}
private VehiclesFactory() {
}
}
class Person{
private String name;
private Vehivles vehivles;
//在创建人对象时,事先给他一个交通工具
public Person(String name, Vehivles vehivles) {
this.name = name;
this.vehivles = vehivles;
}
//可以把具体要求封装成方法
//如何不浪费,在构建对象时,传入的交通工具对象
//如何防止始终使用的是传入的马对象 instanceof
public void passRiver(){
// if (vehivles==null){
//这里使用的是多态
if (!(vehivles instanceof Boat)){
vehivles =VehiclesFactory.getBoat();
}
vehivles.work();
}
public void common(){
//得到马儿
//判断vehicles属性是否已经存在
//
if (!(vehivles instanceof Horse)){
//这里使用的是多态
vehivles =VehiclesFactory.getHorse();
}
vehivles.work();
}
}
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Homework7 {
public static void main(String[] args) {
Car car1=new Car(34);
car1.f();
Car car2=new Car(43);
car2.f();
Car car3=new Car(-1);
car3.f();
}
}
class Car{
private double temperature;
class Air{
public void flow(){
if(temperature>40)
{
System.out.println("吹冷气");
}
else if(temperature>=0)
{
System.out.println("关闭空调");
}
else {
System.out.println("吹暖气");
}
}
}
public Car(double temperature) {
this.temperature = temperature;
}
public void f(){
new Air().flow();
}
}
package com.hspedu.annotation_;
/**
* @author 林然
* @version 1.0
*/
public class Homework8 {
public static void main(String[] args) {
Color green = Color.GREEN;
green.show();
//在switch中放入枚举对象
switch (green){
case RED:
System.out.println("红色");break;
case BLUE:
System.out.println("蓝色");break;
case BLACK:
System.out.println("黑色");break;
case GREEN:
System.out.println("绿色");break;
case YELLOW:
System.out.println("黄色");break;
default:System.out.println("颜色错误");break;
}
}
}
enum Color implements IColor{
RED(255,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 blueValue;
Color(int redValue, int greenValue, int blueValue) {
this.redValue = redValue;
this.greenValue = greenValue;
this.blueValue = blueValue;
}
@Override
public void show() {
System.out.println("属性值为:"+redValue+","+greenValue+","+blueValue);
}
}
interface IColor{
void show();
}