java基礎10

1:內部類
(1)把類定義在一個類的內部。
(2)特點：
A:內部類可以直接使用外部類的成員，包括私有。
B:外部類要使用內部類成員，必須創建對象使用。
(3)內部類的分類：
局部內部類：定義在方法中的內部類
成員內部類：定義在類中方法外的內部類
(4)成員內部類
class Outer {
class Inner {

}
}


普通的修飾的時候：
外部類名.內部類名 變量 = 外部類對象.內部類對象;
Outer.Inner oi = new Outer().new Inner();


class Outer {
static class Inner {

}
}
用靜態修飾後：
外部類名.內部類名 變量 = 外部類名.內部類對象
Outer.Inner oi = new Outer.Inner();


成員內部類：
private：爲了數據的安全。
static：爲了方便調用。
(5)局部內部類
A:帶名字的局部內部類
class Outer {
public void method() {
class Inner {
public void show() {
System.out.println("show");
}


Inner i = new Inner();
i.show();
}
}

}

局部內部類：

可以訪問外部類中的成員

可以訪問局部成員，但它必須被final修飾

爲什麼？

因爲局部變量使用完畢就消失了。而內部類還在內存中存在，這個時候還要使用局部變量所以爲了延長它的生命週期用final修飾

B:匿名內部類(掌握)
a:沒有名字的內部類。其本質是一個對象。
b:前提：存在一個抽象類或者接口。
c:格式：
new 抽象類或者接口() {
重寫父類方法;
};

本質：是一個繼承了類或者實現了接口的子類匿名對象。

這個裏面的方法怎麼用？

因爲它本身就是一個對象，可以用點（.) 調用即可

如果他有多個方法，可以用父類接收，形成多態

(6)面試題：

interface Inter
{
	void show();
}

class Outer
{
	//補齊代碼，完成主方法中定義的功能
	public static Inter method() {
		/*
		Inter i = new Inter(){
			public void show() {
				System.out.println("HelloWorld");
			}
		};
		return i;
		*/

		return new Inter(){
			public void show() {
				System.out.println("HelloWorld");
			}
		};
	}
}

class InnerClassTest
{
	public static void main(String[] args)
	{
		Outer.method().show(); 
		/*
			分析：
				A: Outer.method()我們要知道在Outer中有一個靜態方法method。
				B：Outer.method().show() 這個返回值居然還可以繼續調用show方法。
										 那麼，說明這個返回值應該是一個包含有show方法的對象。
		*/
	}
}

2:包
(1)包就是永遠區分相同類在不同文件夾下。其本質就是一個文件夾。
(2)包的作用：讓相同類名的類可以存在。
(3)定義包：
package 包名.包名...;
(4)帶包的編譯和運行(理解)
A:方式一
手動式
a:javac編譯代碼
b:手動建立包，把class扔進去
c:java執行，帶全路徑
B:方式二
自動式
a:通過javac編譯自動生成包
javac -d . 文件名
b:通過java運行class文件
java 包名.包名.class文件名不帶擴展名
(5)不同包下的類之間的訪問。
權限夠大才行。


以後，我們所有定義的類都用public修飾。
(6)面試題：
在同一個java文件中，可不可以有多個類?可以。
而我們知道類是可以用public修飾的,那麼，可不可以多個類都用public修飾?不可以。
並且，一般的時候，如果有main方法也存在的時候，都是public修飾帶main那個類。
文件名必須和該public修飾的類名一致。


3:導包
(1)如果多次使用一個多級包的類，每次帶全路徑太麻煩，我們就考慮使用導包。
(2)導包的格式：
import 包名.包名...;


注意：
在同一個包下如果有多個類被使用，可以使用通配符*來導入，但是不建議。
推薦：使用誰導入誰。
(3)面試題：
package，import，class出現的位置?
package > improt > class


4:權限修飾符
(1)用於保證在不同的情況下可以使用
(2)使用如下

				本類	同一個包下	不同包下的子類	不同包下的無關類
		private		Y
		默認		Y	Y
		protected	Y	Y		Y
		public		Y	Y		Y		Y

5:權限修飾符的組合使用及常見使用

		類	成員變量	構造方法	成員方法
private			Y		Y		Y	
默認		Y	Y		Y		Y
protected		Y		Y		Y
public		Y	Y		Y		Y
abstract	Y					Y
final		Y	Y				Y
static			Y				Y

常見的組合規則：
權限修飾符+abstract/final/static+...


我們到底怎麼用：
類：
public class Demo {

}


成員變量：
變量：private String name;
常量：public static final int X = 10;


構造方法：
不讓外界創建：private Demo(){}
大部分：public Demo(){}


成員方法：
不讓外界用：private void show(){}
大部分：public void method()

抽象方法：public abstract void function();

/*
	求Sn=a+aa+aaa+…+aa…a(n個a)之值，
	其中a是一個數字，n表示a的位數，兩個數據都是從鍵盤錄入，
	例如：當鍵盤錄入的 a=2,n=5時:
	sn = 2 + 22 + 222 + 2222 + 22222 

	分析：
		A:從鍵盤錄入數據。錄入a和n。
			a表示數字的值
			n表示對於的a最大有幾位。
		B:求和變量。
		C:分析數據組成規律
			 定義一個初始化值叫做a，定義每一個數據叫做an。第n項。
			 第一個數據：a1 = 2	 =	a;
			 第二個數據：a2 = 22 =	a1*10+a;
			 第三個數據：a3 = 222 = a2*10+a;
			 第四個數據：a4 = 2222 = a3*10 + a;
			 第五個數據：a5 = 22222 = a4*10 + a
*/
import java.util.Scanner;

class NumberTest {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		System.out.println("請輸入a的值：");
		int a = sc.nextInt(); //2
		System.out.println("請輸入n的值：");
		int n = sc.nextInt(); //5

		//定義求和變量
		int sum = 0;
		//定義通項的值
		int an = 0;

		for(int x=0; x<n; x++) {
			an += a; //an=2,an=22,an=222,an=2222,an=22222
			sum += an; //sum=2,sum=24,sum=246,sum=2468,sum=24690
			an*=10; //an=20,an=220,an=2220,an=22220,an=222220
		}

		System.out.println(sum);

		//System.out.println(2 + 22 + 222 + 2222 + 22222 );
	}
}