java中的內部類和自動拆裝箱

內部類

1.什麼是內部類？

答：定義在類中的類

2.怎麼用的？

答：就像在類中定義屬性一樣

修飾符 class 類名{}

第一：內部類相當於是外部類中的一個屬性

第二：內部類本身也就是一個類，跟正常的類一樣

3.為什麼要用它？

答：縮短類的生命週期

劃分：內部類、區域性內部類、匿名內部類

一：內部類

public class Outer { //建立外部類
	public int count;

	public void show() {
		System.out.println("count=" + count);
	}
	public class Inner { //建立內部類
		public void run() {
			System.out.println("Inner run");
		}
	}

思路：1、把內部類當成是外部類中的一個成員，那麼想要找到內部類就需要有外部類的物件
2、run方法需要物件進行呼叫的，而內部類的物件又需要外部類的物件進行呼叫
3、外部類.內部類 變數名 = 外部類物件.內部類物件
4、Outer.Inner inner = new Outer().new Inner();

public static void main(String[] args) {
		  //非靜態內部類建立物件
		 //外部類.內部類 變數名 = 外部類物件.內部類物件 
		Outer.Inner inner = new Outer(). new Inner();
		inner.run();

注意：1.當需要呼叫Inner類中的run方法時，要將內部類當成一個類來理解

​ 2.當需要通過外部類來使用內部類時，首先需要將它看做一個外部類中的非靜態屬性來理解

/**
	 * 用於呼叫Inner類中的run方法
	 */
	public void method() {
		Inner inner = new Inner();
		inner.run();
	}

method方法引用Inner類的run方法，就需要先建立物件，才能進行呼叫

此時可以用Outer物件呼叫method方法：

public static void main(String[] args) {
		  //非靜態內部類建立物件
		 //外部類.內部類 變數名 = 外部類物件.內部類物件 
		Outer.Inner inner = new Outer(). new Inner();
		inner.run();
		
		Outer outer =new Outer();
		outer.method();

內部類和不同的修飾同時存在時的特點：

1.對於該成員變數，其生命週期和物件的生命週期一致，作用域在整個類中都可以使用，呼叫形式：使用物件呼叫

2.private修飾後，該類就只能在當前類中使用
3.static修飾後，該類的生命週期和外部類的生命週期一致，就失去了內部類本身的意義
4.final修飾後，該類無法被繼承

//在內部類中區分this關鍵詞的所屬

內部類可以呼叫外部類的屬性和方法，但是外部類只能通過物件的形式去呼叫內部類中的屬性和方法

public class Practive {
 private int count =5 ;
  class Inner{
	  int count =6;
	   public void show() {
		   int count=7;
		   System.out.println("count:"+ Practive.this.count);
	   }
  }
  public static void main(String[] args) {
	Practive .Inner inner = new Practive().new Inner();
	inner.show();
}
}

同一個類中方法及屬性之所以可以互相呼叫，是因為都預設持有一個this物件

在繼承中，子類中之所以可以直接呼叫父類中的方法是因為呼叫的父類方法或屬性都預設持有一個super屬性

二.區域性內部類

1.區域性變數只能在方法中使用

2.區域性內部類本身也相當於一個區域性變數，而其本身也是一個類

3.區域性內部類就是定義在方法中的類，生命週期和方法的生命週期一致，作用域只在方法中

4.從方法的角度來使用，它要作為一個區域性變數來使用，從自身的角度(需要使用類中的方法及屬性)作為一個類來使用

public class AreaInnerDemo {

	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.method();

	}
}

class Outer{
	
	public void method() {
		class Inner{
			public void show() {
				System.out.println("--show--");
			}
		}
		Inner inner = new Inner();
		inner.show();
	}
}

區域性內部類中想要呼叫show方法， 需要先在method 方法中建立inner物件，然後在主函式中建立outer物件之後，再去呼叫method方法

三.匿名內部類

1.概念：定義在類中或方法中的內，該類沒有具體的含義及名字

沒有名字的內部類，沒名字說明不經常用，內部類作用是為了縮短生命週期

2.匿名內部類實現語法：父類類名 名字 = new 父類型別(){};

​ new 父類型別(){}相當於就是一個子類物件

3.父類類名 名字 = new 父類型別(){};是多型形式，向上轉型

public class NiMingInnerDemo {

	public static void main(String[] args) {
		Animal animal = new Animal() {

			@Override
			public void eat() {
				System.out.println("沒有名字的類");
			}

			@Override
			public void sleep() {
				System.out.println("第二個方法");
			}
//			public void show() { 介面中沒有的方法是不能在匿名內部類中使用的
//				System.out.println("展示");
//			}
			};
			animal.eat();
			animal.sleep();

	}

}
interface Animal{
	void eat();
	void sleep();
}
class Cat implements Animal{

	@Override
	public void eat() {
		
	}

	@Override
	public void sleep() {
		
	}
}

自動拆裝箱

1.自動拆裝箱可以簡單理解為基本資料型別的包裝類

2.問題：為什麼要對基礎資料型別進行包裝？

答：因為Java是一種面嚮物件語言，很多地方都需要使用物件而不是基本資料型別。比如，在集合類中，我們是無法將int 、double等型別放進去的。因為集合的容器要求元素是Object型別。

為了讓基本型別也具有物件的特徵，就出現了包裝型別，它相當於將基本型別“包裝起來”，使得它具有了物件的性質，並且為其新增了屬性和方法，豐富了基本型別的操作。

簡單來說就是讓它可以有更多的功能去使用。

3.基礎資料型別對應的包裝類：

byte – Byte； short–Short ; char–Character; int --Integer

long – Long ; float – Float ; double – Double ; boolean – Boolean

public static void main(String[] args) {
		 int num =5;
		 //Integer integer = new Integer(6);
		 Integer integer=6;
		 System.out.println(integer); // 6
		 System.out.println("-------------");
		 
		 Integer integer1 = 127;
		 Integer integer2 = 127;
		 System.out.println(integer1 == integer2);//true  比較的是數值
		 System.out.println("-------------");
		 
		 Integer integer3 = new Integer(127);
		 Integer integer4 = new Integer(127);
		 System.out.println(integer3 == integer4);// false 兩個不同的地址
		 System.out.println(integer3.equals(integer4)); //true 先比較地址 再比較內容
		 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));// true  數值相同,當數值大於127之後，可以使用new物件的方式
		 System.out.println("-------------");
		 
		 Integer integer7= 128;
		 Integer integer8= 128;
		 System.out.println(integer7.equals(integer8));// true
		 
		//所有基本資料型別包裝類中都提供了一個緩衝池
		//緩衝池：將常用的資料存放到緩衝池中，以提高效率，儲存的是固定的-128~127之間
		//所有的賦值操作都是自動裝箱，所有的運算都是自動拆箱
		 Integer integer9 =112;
		 Integer integer0 =113;
		 int result = integer9 -integer0;//從包裝類拆成了數字運算
		 System.out.println(result); // 輸出-1 
		 System.out.println("-------------");
		 
		 //所有的包裝類中都提供了一個與字串相互轉換的方法
		 String count ="6";
		 int count2 = Integer.valueOf(count);
		 System.out.println(count2+1); //輸出：7  如果沒有轉換成數字，結果應該是6+1
	}

使用場景： 前段使用的輸入框，使用者輸完內容後，獲取的數字型別是字串，為了方便，前段可能直接將資料傳遞到後臺