Java学习笔记（七）包装器、枚举类、内部类、静态内部类、局部类、匿名内部类

一、包装器

基本类型	包装类
int	Integer
short	Short
long	Long
char	Character
byte	Byte
float	Float
double	Double
boolean	Boolean

1.装箱

int num1 = 1;
Integer Num1 = new Integer(num1);    //装箱
Integer Num1 = new Integer.valueOf("1");
Integer Num2 = num1;                 //自动装箱

2.拆箱

int num2 = Num1.intValue();        //拆箱
int num3 = Num1                    //自动拆箱

3.使用包装类后的一些常用方法Integer举例，其他类似

• int intValue()                                           以int的形式返回对象的值
• static String toString(int i)                       以新的String对象形式返回给定数值 i 的十进制表示
• static int parseInt(String s)
• static int parseInt(String s, int radix)      返回字符串s表示的整型数值，给定字符串表示的是十进制的整数或是radix参数进制
• static Integer valueOf(String s)
• static Integer valueOf(String s, int radix) 返回用s表示的整型数值进行初始化后的一个新的Integer对象

二、枚举类

1.枚举类的定义

enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE};

2.枚举类的引用

Size size = Size.SMALL;    //枚举类里自带 public static final 属性

 

三、内部类

1.什么是内部类，为什么要内部类？

内部类是定义在另一个类中的类。使用内部类有以下几点主要原因

1. 内部类方法可以访问该类定义所在的作用域中的数据，包括私有数据
2. 内部类可以对同一个包中的其他类隐藏起来
3. 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷

2.内部类的定义与使用

public class Hello 
{

	public static void main(String[] args) 
	{
		// TODO Auto-generated method stub
		
		Outer outer = new Outer();
		Outer.Inner inner = outer.new Inner(); //创建内部类的实例
		outer.printInnerData();
		inner.printData("HELLO JAVA");
	}
}

public class Outer{//外部类
	private String data = "Hello Java";

	public void printInnerData() {
		Inner inner = new Inner();
		System.out.println("Inner data: " + inner.getData());
	}
	
	public class Inner{//内部类
		
		private String data = "hello java";
		
		public void printData(String data) {
			System.out.println("para： " + data);
			System.out.println("Inner data: " + this.data);
			System.out.println("Outer data: " + Outer.this.data);
		}

		public String getData() {
			return data;
		}
	} 
	
}

运行结果：

2.1. 内部类的定义

• 定义的话只要将类的定义置在一个类的内部即可（编译器会生成xxxx$xxx.class的文件）

• 内部类不能与外部类同名

2.2. 内部类的使用

1. 在外部类中使用内部类，与普通类的使用方式相同，如在外部类里，访问内部类的属性：

   public void printInnerData() {//Outer外部类的方法
   	Inner inner = new Inner();
   	System.out.println("Inner data: " + inner.getData());
   }

    

2. 内部类里访问外部类的属性，需要指明外部类名，外部类.this.外部类属性，如：

   public void printData(String data) {
   	System.out.println("para： " + data);
   	System.out.println("Inner data: " + this.data);
   	System.out.println("Outer data: " + Outer.this.data);
   }

3. 在外部类外部，创建内部类的实例，（需要借助外部类的实例），外部类.内部类  inner = new  外部类().new  内部类，如：

   Outer outer = new Outer();
   Outer.Inner inner = outer.new Inner();

 

3.静态内部类

3.1. 静态内部类的定义

用static修饰内部类时，表明该内部类实际上是一种外部类了，因为它与外部类的实例无关了。

3.2. 静态内部类的使用

• 实例化static类时，在new前面不需要用对象实例变量
• static类中不能访问其外部类的非static的字段及方法，只能访问static成员

 

4.方法内部类

4.1 方法内部类定义

方法内部中定义的类，称为局部类，也被称为方法中的内部类。

4.2 局部类的特点

1. 局部类同局部变量一样，不能被public、protected、private、static修饰
2. 但其可以被final、abstract修饰
3. 可以访问其外部类的成员
4. 可以访问形参，因为形参在JDK8后变为隐式的final声明
5. 可访问局部变量，但不建议如此使用

   public class Hello 
   {
   
   	public static void main(String[] args) 
   	{
   		// TODO Auto-generated method stub
   		
   		LocalClass lc = new LocalClass();
   		lc.testLocalClass("para");
   	}
   }
   
   public class LocalClass {
   	private String data = "class";
   	
   	LocalClass(){
   		
   	}
   	
   	public void testLocalClass(String para) {
   		String local = "local";
   		
   		class Inner{
   			public void usepara() {
   				System.out.println(data); //访问外部类的属性
   				System.out.println(para); //访问形参
   				System.out.println(local);//访问局部变量
   			}
   		}
   		new Inner().usepara();
   	}
   }
   

   结果：

 

5.匿名内部类

匿名类是一种特殊的内部类，它没有类名，在定义类的同时就生成该对象的一个实例，是“一次性使用”的类

5.1 匿名内部类特点

1. 匿名内部类必须继承一个抽象类或者实现一个接口
2. 不取名字，直接用其父类或接口的名字，也就是说，该类是父类的子类，或者实现了一个接口，而编译器会生成 xxxx$1之类的名字
3. 由于没有名字，所以不能有构造方法，如果在new需要带参数，则使用父类的构造方法
4. 不使用关键词class，也不使用extends或implements
5. 类的定义的同时就创建实例，即在类的定义前面有一个new，即 new 类名或接口名 () {}

   public void test() {
   	new MyTest ("Li Ming") {	//Mytest为已定义好的抽象类，构造方法需要传参
   		public void sayHello() {
   			System.out.println("hello my name is "+ this.name);
   		}
   	}.sayHello();
   }