形式引數-返回值-內部類-匿名內部類

阿新 • • 發佈：2019-01-11

一.形式引數和返回值

1.基本資料型別：

你要什麼資料型別，實際傳參的時候就傳什麼資料型別，形式引數的改變對實際引數沒有影響(String是引用型別，但和基本型別的效果一樣String s = "luo")。 關於String:String a = "abc"和String s = new String("abc")的區別 在Java虛擬機器(JVM)中存在著一個字串池，其中儲存著很多String物件，並且可以被共享使用，因此它提高了效率。String a = "abc"；在執行這個程式碼的時候，Java虛擬機器首先在字串池pool中查詢是否已經存在了“abc”的這麼一個物件，判斷依據是String類equals(Object obj)方法的返回值。如果有，則不再建立新的物件，直接返回已存在物件的引用；如果沒有，則先建立這個物件，然後把它加入到字串池中，再將它的引用返回。

對於String s = new String("abc");語句，這裡“abc”本身就是Pool中的一個物件，而在執行時執行new String()時，將pool中的物件複製一份放到堆中，並且把堆中的這個物件的引用交給s持有，建立了兩個String物件。第二種方式建立了兩個String物件，增加了效能開銷，所以建議避免使用這種方式建立String物件。

class Demo{
	//成員方法
	public int sum(int a,int b){
		return (a+b);
		
	} 
}


public class BasicDataTest {

	public static void main(String[] args) {
		Demo d = new Demo();
		int result = d.sum(3, 4);      //3、4是實際的兩個引數
		System.out.println("result = "+result);
		System.out.println("-------------");
		
		String str1 = "fly";
		String str2 = "weight";
		String str3 = "flyweight";
		String str4 = null;
		
		str4 = str1 + str2;
		System.out.println(str3 == str4);	//false
		
		/*
		 * str3和str4指向同一個物件，通過intern()方法來實現,會先在字串常量池中尋找內容為“flyweight”的地址，
		如果找到，就將str4變數指向這個地址，如果找不到，就將建立一個字串常量並將其加入到常量池中，此處已有這個地址，
		所以str4指向這個地址。即str3和str4變數指向為同一個地址，兩個引用指向同一個字串物件。
		*/
		
		str4 = (str1 + str2).intern();
		System.out.println(str3 == str4);	//true

	}

}

2.引用型別：具體類、抽象類、介面

1）具體類:

形式引數：如果形式引數是一個具體的類，那麼需要建立該類物件

class Student{
	public void show(){
		System.out.println("好好學Java！");
	}
}

class StudentDemo{
	public void method(Student s){	//形式引數是一個引用型別，那麼需要該類物件Student s = new Student();
		s.show();
	}
}

public class ConcreteDemo {

	public static void main(String[] args) {
		//需求：呼叫StudentDemo中的method()方法，則需要建立StudentDemo這個類的物件
		
		StudentDemo sd = new StudentDemo();
		//建立Student類的物件
		Student s = new Student();
		sd.method(s);    //s代表Student類的物件，把空間地址值作為引數傳遞
		

	}

}

返回值：方法的返回值是一個具體的類，那麼需要建立該類物件

class Student{
	public void show(){
		System.out.println("好好學Java！");
	}
}

class StudentDemo{					//如果方法的返回值是一個具體的類，那麼需要該類的物件
	public Student method(){
		/*
		 Student s = new Student();
		return s;
		*/
		return new Student();      //匿名物件
	}
}

public class ConcreteDemo {

	public static void main(String[] args) {
		
		 //需求：呼叫StudentDemo中的method()方法，則需要建立StudentDemo這個類的物件

		StudentDemo sd = new StudentDemo();
		Student s = sd.method();     //返回的是一個Student型別的物件
		s.show();                    //再呼叫Student類中的show()方法
	}

}

2）抽象類：

形式引數：需要再定義一個抽象類的子類，來進行例項化（建立物件！）建立物件的實質：抽象類多型！

//宣告一個抽象類
abstract class Person{
	public abstract void study();
}

//定義一個PersonDemo類
class PersonDemo{
	//定義一個帶有形參的成員方法
	public void method(Person p){	//Person p = new Person()是錯誤的，因為抽象類不能例項化，
									//需要再宣告一個抽象類的子類，通過抽象類多型例項化
		
		p.study();
	}
}

//宣告抽象類的子類
class Person2 extends Person{
	//重寫抽象類中的抽象方法
	public void study(){
		System.out.println("好好學Java！");
	}
}

//測試類
public class AbstractDemo {
	public static void main(String[] args) {
		//呼叫PersonDemo中的method()方法；
		PersonDemo pd = new PersonDemo();
		
		//需要使用抽象類多型實現化
		Person p = new Person2();
		pd.method(p);
		
		/*//鏈式程式設計： 
		new PersonDemo().method(new Person2());
		*/

	}

}

返回值：返回值如果是抽象類，需要返回的是該抽象類的子類物件

//宣告一個抽象類

abstract class Person3{
	public abstract void show();
}

//定義PersonDemo2類
class PersonDemo2{
	public Person3 method(){	//如果一個方法的返回值是一個抽象類,需要返回的是該抽象類的子類物件
		Person3 p = new Person4();
		return p;
		//return new Person4(); 
	}
}

//抽象類的子類
class Person4 extends Person3{
	public void show(){
		System.out.println("愛學習！愛Java！");
	}
}
//測試類
public class ReturnAbstract {
	public static void main(String[] args) {
		//呼叫PersonDemo2中的method()方法
		PersonDemo2 pd = new PersonDemo2();
		
		
		Person3 p3 = pd.method();    //返回的是Person3的物件
		p3.show();
		System.out.println("---------");
		
		/*
		 //鏈式程式設計
		Person3 p3 = new PersonDemo2().method();	
		p3.show();
		 */
	}

}

3）介面

形式引數：如果形式引數是介面的情況，那麼需要自定義一個介面的子實現類，然後通過介面多型的形式給介面例項化！

//介面
interface Inter{
	public abstract void love();
}

class TeacherDemo{
	public void method(Inter i){	//介面不能例項化；如果一個方法的形式引數是一個介面，那麼需要建立該介面的子實現類物件
		i.love();
	}
}

//介面不能例項化，需要定義介面的子實現類
class Teacher implements  Inter{
	public void love(){
		System.out.println("teacher love Java!");
	}
}

//測試類
public class InterfaceDemo {
	public static void main(String[] args) {
		//呼叫TeacherDemo中的method()方法
		
		TeacherDemo td = new TeacherDemo();
		//建立該介面物件：通過介面多型
		//Inter i = new Teacher();
		
		//匿名內部類
		Inter i = new Inter(){
			public void love(){
				System.out.println("teacher love Java!");
			}
		};
		td.method(i);
	}

}

返回值：返回值如果是介面型別，需要返回的是該介面子實現類物件（通過子實現類進行例項化！）

//定義介面
interface Inter2{
	public abstract void love();
}

//定義一個返回值是介面的類
class TeacherDemo2{		//如果一個方法的返回值是介面型別，需要返回該介面對應的子實現類的物件
	public Inter2 method(){
		Inter2 i = new Teacher2();
		return i;
		
		//return new Teacher2();
	}
}
//介面的子實現類
class Teacher2 implements Inter2{
	public void love(){
		System.out.println("teacher love Java!");
	}
}

//測試類
public class ReturnInterface {
	public static void main(String[] args) {
		TeacherDemo2 td = new TeacherDemo2();
		Inter2 inter2 = td.method();
		inter2.love();

	}

}

二.內部類

1.概念：在一個類中定義另一個類，稱為內部類。

eg:在類A中定義一個類B，那麼類B是類A的內部類，同理，類A就是類B的外部類。內部類是直接可以訪問外部類的成員，包括私有。外部類要訪問內部類的成員，必須通過建立內部類的物件訪問該內部類的成員。

class Outer{
	//外部類的成員變數
	public int num = 10;
	private int num1 = 20;
	
	//內部類
	class Inner{
		//內部類的成員方法
		public void show(){
			//內部類可以直接訪問外部類的成員，包括私有
			System.out.println("num = "+num);
			System.out.println("num1 = "+num1);
			
		}
	}
	
	//外部類的成員方法
	public void method(){
		//外部類不能直接訪問內部類，必須建立內部類的物件
		Inner i = new Inner();
		i.show();
	}
	
}
//測試類
public class InnerDemo {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}

2.內部類的分類：成員內部類、區域性內部類

package day_09_10_24;
//外部類
class Outer{
	
	//外部類的成員變數
	public int num = 12;
	
	//成員內部類
	class Inner{
		
	}
	
	//外部類的成員方法
	public void method(){
		//區域性內部類
		class Inner2{
	
		}
	}	
}

//測試類
public class InnerClass {
	public static void main(String[] args) {
		
	}

}

1）成員內部類：在外部類的成員位置，測試類中需要訪問成員內部類中的成員方法：外部類名.內部類名物件名 = 外部類物件.內部類物件；

package day_09_10_24;

//外部類
class Outer3{
	//定義外部類的變數
	public int num = 10;
	
	//成員內部類（非靜態成員內部類）
	class Inner3{
		//內部類的成員方法（非靜態的成員方法）
		public void show(){
			System.out.println("num = "+num);
		}
	}
	
	//外部類的成員方法
	public void method(){
		
	}
}
//測試類
public class MemberInner {

	public static void main(String[] args) {
		/**
		 * 需求：訪問Inner3成員內部類中的show()方法
		 * 外部類名.內部類名 物件名 = 外部類物件.內部類物件;
		 */
		
		Outer3.Inner3 oi = new Outer3().new Inner3();
		oi.show();
	}

}

成員內部類修飾符：

private :為了保證數的安全性，外部類訪問成員內部類方法：外部類

package day_09_10_24;

class Body{
	public String heart;
	//成員內部類
	private class Inner{
		public void operator(){
			System.out.println("醫生做手術");
		}
	}
	
	//成員方法
	public void behave(){
		boolean flag = true;
		if(flag){
			Inner i = new Inner();
			i.operator();
		}
	}
}


public class MemberInnerPrivate {
	public static void main(String[] args) {
		/**
		 * 成員內部類被private修飾，直接建立外部類物件，通過外部類成員方法間接訪問內部類成員方法
		 * */
		Body b = new Body();
		b.behave();
	}

}

static：為了方遍呼叫，如果成員內部類被static修飾，那麼要訪問外部類的成員變數，這個變數必須被static修飾靜態的成員內部類訪問該類中的成員方法：外部類名.內部類名物件名 = new 外部類名.內部類名（）；

package day_09_10_24;

class Outer4{
	//外部類的成員變數
	
	public static int num1 = 10;
	public static int num2 = 20;
	/**
	 *對於靜態的成員內部類，無論其中的方法是靜態的還是非靜態的，要訪問外部類的成員變數，該變數必須被static修飾 
	 **/
	public static class Inner4{
		//靜態的內部成員方法
		public static void show(){
			System.out.println("num1 = "+num1);
			System.out.println("num2 = "+num2);
		}
		
		//非靜態的內部類的成員方法
		
		public  void show2(){
			System.out.println("num1 = "+num1);
			System.out.println("num2 = "+num2);
		}
	}	
}
//測試類
public class MemberInnerStatic {
	public static void main(String[] args) {
		/**
		 * 需求：要訪問靜態成員內部類Inner4裡面的show(),show2()方法
		 * 外部類名.內部類名 物件名 = new 外部類名.內部類名();
		 * */
		Outer4.Inner4 oi = new Outer4.Inner4();
		oi.show2();
		oi.show();  //靜態方法
		System.out.println("------------");
		//show的另一種訪問方法；
		Outer4.Inner4.show();  //靜態方法可以直接通過類名方法
		
		
	}

}

2）區域性內部類：定義在外區域性類的區域性位置

區域性內部類訪問該類中的成員方法：直接建立外部類的物件，通過外部類物件訪問外部類方法結論：無論是區域性內部類還是成員內部類（非靜態的）都可以直接訪問外部類的成員，包括私有成員

package day_09_10_24;

class Outer5{
	public int num1 = 10;
	private int num2 = 20;
	
	//外部類的成員方法
	public void method(){
		//區域性變數
		final int num3 = 20;  //自定義常量
		
		//區域性內部類
		class Inner5{
			public void show(){
				System.out.println("num1 = "+num1);
				System.out.println("num2 = "+num2);
				
				//區域性內部類中訪問區域性變數
				System.out.println("num3 = "+num3);//jdk1.7才會有這個錯誤!	jdk1.8--->封裝好了,所以不會出現錯誤!
			}
		}
		
		Inner5 i = new Inner5();
		i.show();
	}
}
//測試類
public class InnerLocal {
	public static void main(String[] args) {
		//對於區域性內部類訪問該類中的成員方法：建立外部類物件，使用外部類物件呼叫外部類的成員方法
		Outer5 o = new Outer5();
		o.method();
	}

}

面試題：區域性內部類訪問區域性變數會出現問題？（比如上例中的區域性變數num3） 當前區域性變數會報錯，必須用final修飾； 為什麼用final修飾？ 由於區域性變數是隨著方法呼叫而生產的，隨著方法的呼叫完畢消失，而現在區域性位置有一個區域性內部類，它要在自己的成員方法位置訪問當前的區域性變數，必須把變數變成一個常量（需要用final:自定義常量），這樣的一個變數的值是永遠固定的。

三.匿名內部類

內部類的簡化版格式 前提條件：必須存在一個介面或者一個類（可以是具體類，也可以是一個抽象類） 格式： new 介面或者類名{ 方法重寫； } 匿名內部類的實質：繼承了該類（抽象類）或者是實現了該介面的子類物件

package day_09_10_24;


//定義一個介面
interface Inter9{
	//抽象功能
	public abstract void show();
	public abstract void show2();
}

//外部類
class Outer6{
	//成員方法
	public void method(){
		
		/*//當介面中只有一個方法的情況
		new Inter9(){
			public void show(){
				System.out.println("匿名內部類");
			}
		}.show();
	}*/
	
	
		//匿名內部類.介面中有兩個方法的時候
		Inter9 i = new Inter9(){
			//方法重寫
			public void show(){
				System.out.println("show匿名內部類");
			}
			
			public void show2(){
				System.out.println("show2匿名內部類");
			}
		};
	
		i.show();
		i.show2();
	}
}
public class InnerDemo2 {

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

	}

}

package day_09_10_24;

/**
 * 匿名內部類在開發中的使用
 * */

interface Inter3{
	public abstract void study();
}

class StudentDemo1{
	public void method(Inter3 i){  //形式引數是介面
		i.study();
	}
}

//方式1：
class Adess implements Inter3{
	public void study(){
		System.out.println("好好學習，天天向上。。。");
	}
}

public class OuterTest {

	public static void main(String[] args) {
		//呼叫StudentDemo1中的method()方法
		StudentDemo1 sd = new StudentDemo1();
		
		Inter3 i = new Adess();
		sd.method(i);
		//i.study();
		System.out.println("---------------");
		
		//方式2：匿名內部類
		StudentDemo1 sd2 = new StudentDemo1();
		sd2.method(new Inter3(){
			//方法重寫
			public void study(){
				System.out.println("好好學習，天天向上。。。");
			}
		});
	}

}

package day_09_10_24;
/**
 * 匿名內部類面試題：
		按照要求，補齊程式碼
			interface Inter { void show(); }
			class Outer { //補齊程式碼 }
			public class InterTest {
				public static void main(String[] args) {
					  Outer.method().show();
				  }
			}
			要求在控制檯輸出”HelloWorld”
 
分析：
 * 當前method()能直接被類名呼叫---->method()方法是一個靜態方法static 
 * Outer.method().show()---->Outer.method()返回的是一個物件，拿物件呼叫show()方法
 * 介面只有一個show()方法，需要重寫show()方法
 * */

//介面
interface Inter5{
	public abstract void show(); 
}

//外部類
class Outer8{
	//補齊程式碼
	public static Inter5 method(){	//返回值是一個介面
		return new Inter5(){
			//重寫show方法
			public void show(){
				System.out.println("HelloWorld!");
			}
		};
		
	}
}
//測試類
public class InterTest {
	public static void main(String[] args) {
		Outer8.method().show();

	}

}

package day_09_10_24;
/**
 * 
 * 看程式
 * 面試題：
		要求請填空分別輸出30，20，10。
		
		外部類和內部類沒有繼承關係!
 * */

class Outer7 {
	public int num = 10;
	
	class Inner7 {
		public int num = 20;
		public void show() {
			int num = 30;
			System.out.println(num);  //30
			System.out.println(this.num); //20;this指當前物件
			System.out.println(new Outer7().num);//10;要訪問外部類的成員變數:匿名物件 :new 外部類名().成員變數
			//外部類的this限定
			System.out.println(Outer7.this.num);//10
			
		}
	}
}
//測試類
public class InterclassTest {
	public static void main(String[] args) {
		Outer7.Inner7 oi = new Outer7().new Inner7();
		oi.show();
	}
}