Java进阶总结7——内部类、枚举

爱被打了一巴掌 2022-05-17 00:44 103阅读 0赞

# 1.内部类 #

>  \* 内部类：在类的内部定义一个类，可以看做类的成员  
>  \* 类的成员：字段、方法、类  
>  \* 内部类类型：  
>  \*         1.实例内部类  
>  \*         2.静态内部类  
>  \*         3.局部内部类  
>  \*         4.匿名内部类

##  1.1 实例内部类 ##

>      \* 实例内部类  
>      \*         位置：类中，方法外  
>      \*         修饰符：public、private、protected、默认  
>      \*         不能有：static  
>      \*         类中定义的成员  
>      \*                 不能使用static进行修饰  
>      \*                 访问权限修饰符：都可以  
>      \*         内部类访问外部类的成员  
>      \*             在内部类中可以直接访问外部类的成员（实例和静态）

package day13.innerclass;
    
    public class OutDemo1 {
    	//外部类的属性
    	String name;
    	int age;
    	//外部类的方法
    	public void method1() {
    		System.out.println("外部类");
    	}
    	//定义一个实例内部类
    	class Inner{
    		//定义内部成员
    		String name;
    		//static int  num;//不能使用static进行修饰
    		public void printmsg() {
    			System.out.println("实例类的内部方法:"+name);
    		}
    		public void printOutMsg() {
    			//如果外部类成员和内部类成员一致，默认访问的是内部类成员
    			//如果是访问外部类成员
    			System.out.println(OutDemo1.this.name);
    			//调用外部类的method1方法
    			OutDemo1.this.method1();
    			//通过内部类给外部类成员赋值
    			OutDemo1.this.age=21;
    		}
    		public void method1() {
    			System.out.println("内部类");
    		}
    		//构造方法
    		public Inner() {
    			// TODO 自动生成的构造函数存根
    			System.out.println("内部类默认构造方法");
    		}
    		
    	}
    	
    }

package day13.innerclass;
    
    import day13.innerclass.OutDemo1.Inner;
    
    public class TestDemo {
    	public static void main(String[] args) {
    		//使用内部类
    		//初始化外部类
    		OutDemo1 out=new OutDemo1();
    		out.name="浪子一秋";
    		//初始化一个内部类
    		Inner inner=out.new Inner();
    		//给内部类赋值
    		inner.name="尊";
    		//访问内部类的方法
    		inner.printmsg();
    		inner.printOutMsg();
    		inner.method1();
    		//直接初始化一个内部类，但是外部类不能直接访问
    		OutDemo1.Inner in=new OutDemo1().new Inner();
    		in.printOutMsg();
    		
    	}
    }

## 1.2静态内部类 ##

>      \* 静态内部类  
>      \*         位置：类中，方法外  
>      \*         修饰符:只能static abstract  final  public  private  protected  默认  
>      \*         成员：静态，非静态

package day13.innerclass;
    
    public class OutDemo2 {
    	String name;
    	static int number;
    	public void method1() {
    		System.out.println("外部类实例方法");
    		
    	}
    	public static void method2() {
    		System.out.println("外部类静态方法");
    	}
    
    	static class Inner1{
    		String name;
    		static int age;
    		public Inner1() {
    			// TODO 自动生成的构造函数存根
    			System.out.println("内部类默认构造方法");
    		}
    		public void method1() {
    			System.out.println("内部类实例成员");
    			//静态内部类实例成员可以访问外部类的静态成员
    			number=100;
    			name="尊";//代表内部类
    			//OutDemo2.this.name="11";//不允许访问外部类的实例成员
    		}
    		public static void method2() {
    			//只能访问外部类的静态成员
    			System.out.println("内部类静态成员");
    		}
    	}
    	public static void main(String[] args) {
    		//初始化一个静态内部类,没有初始化外部类
    		OutDemo2.Inner1 inner1=new OutDemo2.Inner1();
    		//访问内部类成员,可以访问使用成员
    		inner1.method1();//内部类实例成员
    		inner1.method2();//内部类静态成员
    		//直接访问内部类的静态成员,通过类名访问
    		OutDemo2.Inner1.age=21;
    		OutDemo2.Inner1.method2();
    		//内部类可以访问外部类的静态成员		
    	}
    }

##  1.3局部内部类 ##

>      \* 局部内部类  
>      \*         位置：方法中  
>      \*         成员：必须是实例成员  
>      \* 只能在声明方法中使用

package day13.innerclass;
    
    public class OutDemo3 {
    	//属性
    	String name;
    	int sex;
    	public void methord1() {
    		System.out.println("外部类的实例方法");
    	}
    
    	public void method2() {
    		int num=10;
    		class Inner2{
    			String name;
    			int age;
    			public void method3() {
    				//局部内部类可以访问外部类的所有成员
    				System.out.println(sex);
    				//访问外部类、方法内的局部变量,局部变量必须加上final修饰符，jdk1.8之后不需要加
    				System.out.println(num);
    				System.out.println("局部内部类的实例方法");
    			}
    			/*public static void method4() {
    				
    			}*/			
    		}
    		//初始化一个内部类对象
    		Inner2 in=new Inner2();
    		in.name="尊";
    		in.age=21;
    		in.method3();
    	}
    	public static void main(String[] args) {
    		//初始化一个外部类对象
    		OutDemo3 demo3=new OutDemo3();
    		demo3.method2();
    	}
    }

## 1.4匿名内部类 ##

>      \* 匿名内部类：当前这个类是没有名字的  
>      \* 定义的位置：方法内

package day13.innerclass;
    //声明一个接口
    interface MyInterface{
    	public void sendMsg(String msg);
    }
    public class OutDemo4 {
    	public static void method3(MyInterface face) {
    		face.sendMsg("你好啊");
    	}
    
    	public static void main(String[] args) {
    		//定义了一个匿名的类，类的名字不知道，这个类肯定实现了接口
    		MyInterface face=new MyInterface() {
    			//属性
    			
    			//方法
    			void method2(){
    				System.out.println("Hello");
    			}
    			@Override
    			public void sendMsg(String msg) {
    				// TODO 自动生成的方法存根
    				System.out.println(msg);
    			}
    		};
    		//多态
    		method3(face);
    	}
    }

#  2 枚举 #

>      \* 默认继承java.lang.enum这个类  
>      \* 使用过程中，只用神秘常量  
>      \* 多个常量之间用逗号隔开  
>      \* 常量必须放在第一行  
>      \* 常量都是引用数据类型 ,都是当前枚举的对象

package day13.Test;
    //定义一个枚举类
    enum Weekday3{
    
    	MON,TUES,WEDES,THURS,FRI,SATUR,SUN;
    	//public static final Weekday3 MON=new Weekday3();等价于MON	
    	//枚举类内部，可以声明字段、方法、构造方法、内部类，必须放在常量之后
    	int age;
    	public void method1() {
    		System.out.println("写代码");
    	}
    	//构造方法必须私有化
    	private Weekday3() {}
    }
    public class Employee3 {
    	//属性
    	private Weekday3 restday;
    
    	public Weekday3 getRestday() {
    		return restday;
    	}
    
    	public void setRestday(Weekday3 restday) {
    		this.restday = restday;
    	}
    	//判断是否是休息日
    	public void restDay() {
    		switch (this.restday) {
    			case MON:
    			case	 TUES:
    			case WEDES:
    			case THURS:
    			case FRI:
    			case SATUR:
    				System.out.println("天天写代码");
    				break;
    			case SUN:
    				System.out.println("休息一天");
    				break;
    		}
    	}
    	public static void main(String[] args) {
    		//初始化对象
    		Employee3 em3=new Employee3();
    		//数组属性的值  枚举
    		em3.setRestday(Weekday3.FRI);
    		//判断
    		em3.restDay();
    		//获取枚举对象的名称
    		String name=Weekday3.SUN.name();
    		System.out.println(name);
    		name=Weekday3.FRI.toString();
    		System.out.println(name);
    		//获取枚举对象  常量的序列号 从0开始
    		int index=Weekday3.THURS.ordinal();
    		System.out.println(index);
    		//获取所有的枚举常量，返回一个数组对象
    		Weekday3[]arr=Weekday3.values();
    		for(Weekday3 weekday3:arr){
    			System.out.println(weekday3);
    		}
    		//将string类型转换成枚举常量，要去string名称和枚举常量名称一致
    		Weekday3 day=Weekday3.valueOf("SUN");
    		System.out.println(day);
    		System.out.println(day.ordinal());
    	}
    }

# 3.知识框架 #

![70][]

[70]: /images/20220517/42ff7e0f293e4694bc6f264f3e82a536.png