JAVA基础学习博客008

学习目标：

掌握今日学习内容并理解，可以用自己语言描述，可以自己验证过程

学习内容：

内部类，自动拆装箱

学习时间：

2020 11/16

学习产出：

1.普通内部类

	public class Outer {

	public int count;
	
	//内部类也相当于是外部类中的一个成员变量
	class Inner{
		public int count;
		
		public void show() {
			System.out.println("inner show");
		}
	}
	}
	//思路：1、把内部类当成是外部类中的一个成员，那么想要找到内部类就需要有外部类的对象
	//2、show方法需要对象进行调用的，而内部类的对象又需要外部类的对象进行调用
	//3、外部类.内部类 变量名 = 外部类对象.内部类对象
	//4、Outer.Inner inner = new Outer().new Inner();
	public static void main(String[] args) {
	    Outer outer = new Outer();
	    System.out.println(outer.count);
	    //创建内部类对象
	    Outer.Inner inner = outer.new Inner();
	    inner.show();
	}

内部类和不同的修饰同时存在时的特点：

public class Outer {

	//对于该成员变量，其生命周期和对象的生命周期一致，作用域在整个类中都可以使用，调用形式：使用对象调用
	//可用的修饰符：public private protected static final
	private int count;
	
	//private修饰后，该类就只能在当前类中使用
	//static修饰后，该类的生命周期和外部类的生命周期一致，就失去了内部类本身的意义
	//final修饰后，该类无法被继承
	class Inner{
		private int count;
		
		public void show() {
			System.out.println("inner show");
		}
	}
}
//调用
Outer.Inner inner = new Outer.Inner();
inner.show();
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.show();

• 内部类可以调用外部类的属性和方法，但是外部类只能通过对象的形式去调用内部类中的属性和方法

2.局部内部类

定义在方法中的类，生命周期和方法的生命周期一致，作用域只在方法中

public class Outer2 {

	/**
	 * jdk1.8中内部类所在的方法中的参数默认是final修饰的
	 * jdk1.7及之前需要明确标出final
	 * @param count
	 */
	public void method(int count) {
		int a = 1;
		//count++;
		class Inner{
			public void show() {
				System.out.println("show "+count);
			}
		}
		
		new Inner().show();
	}
	
	public static void main(String[] args) {
		Outer2 outer = new Outer2();
		outer.method(1);
	}
}

3.匿名内部类
定义在类中或方法中的内，该类没有具体的含义及名字,说明不经常用，内部类作用是为了缩短生命周期.

• new 父类类型(){}相当于就是一个子类对象，只是没有名字
• 父类类名 名字 = new 父类类型(){};是多态形式，向上转型

public interface ItemDao{
    public int delUser(int uid);
}
public static void main(String[] args){
    new ItemDao(){
        @Override
        public int delUser(int uid){}
    }.delUser(1);
}
//上述形式，相当于创建了一个子类去实现了ItemDao接口并重写方法
public class ItemDaoImpl implements ItemDao{
    @Override
    public int delUser(int uid){}
}
//单独创建一个类去实现接口和使用匿名内部类实现接口的区别是：使用匿名内部类可节约资源-生命周期短

---

自动拆装箱

• 对于基本数据类型是不存在方法的，在java中如果想要让某个类具备有功能(方法)，那就必须提供一个类的存在；

• 区分：基本数据类型直接赋值使用，引用数据类型可以定义扩展功能更加灵活

• 在某些特定的情况下也需要对基本数据类型做相关的功能，因此就需要提供对应的类，例如：字符串转换为数字

package exceptionDemo;

public class BasePackageClass {
	
	public static void main(String[] args) {
		int num = 5;
//		Integer integer = new Integer(6);
		Integer integer =6;
		System.out.println(integer);
		System.out.println("-------------");
		
		Integer integer1 =127;
		Integer integer2 =127;
		System.out.println(integer1 == integer2);//ture
		
		Integer integer3 = new Integer(127);
		Integer integer4 = new Integer(127);
		System.out.println(integer3 == integer4);//false
		System.out.println(integer3.equals(integer4));//ture
		
		System.out.println("-------------");
		Integer integer5 = new Integer(128);
		Integer integer6 = new Integer(128);
		System.out.println(integer5 == integer6);//false
		System.out.println(integer5.equals(integer6));//ture
		
		System.out.println("-------------");
		Integer integer7 =128;
		Integer integer8 =128;
		System.out.println(integer7 == integer8);//false
		System.out.println(integer7.equals(integer8));//ture
		
		//所有的基本数据类型包装类中都提供了一个缓冲池
		//缓冲池：将常用的数据存放到缓冲池中，从而提高效率，存储的是固定的-128~127之间
		//所有的赋值操作都是自动封箱，所有的运算都是自动拆箱
		Integer integer9 = new Integer(128);
		Integer integer10 = new Integer(128);
		int result = integer9+integer10;
		System.out.println(result);
		System.out.println("-------------");
		//所有的包装类中都提供了一个与字符串转换的方法
		String count = "58";
		int a = Integer.valueOf(count);
		System.out.println(a+1);
	}

}