1.形式參數

參數類型
基本類型，如:int float double

引用類型:
類:這一個時候參數需要的是一個該類的對象。
抽象類:需要的是該抽象的類的子類對象。
接口：需要的是該接口的實現類對象。

2.返回值類型
基本類型:就是一般的基本類型(省略)
引用類型:
類:需要返回的是該類對象。
抽象類:返回的是該抽象類的子類對象。
接口:返回的是該接口的實現類的對象。

3.鏈式編程
所謂的鏈式編程實質就是對象調用方法，然後反復的調用該對象的方法,所以鏈式編程每次調用返回的是一個對象。
new Student().Study().Test();

4.包(package)

(1).什麽是包？
所謂的包就是一個文件夾，那麽包其實就是用於把不同類型的java文件放置在不同的文件夾下面。

(2).包的定義以及相關註意事項
A:定義包需要使用關鍵字package.
B:多級包中間需要使用"."來分隔開。
C:在命名包的時候命名只能夠使用小寫字母。

(3).註意事項
關鍵字package必須放置在java文件的第一個位置。
關鍵字package在一個java文件中只能夠有一個。



5.import關鍵字

(1).import關鍵字
該關鍵字主要是為了解決外部程序之中的相互引用問題。java就給我們提供了使用import關鍵字，用於訪問其他包下面的文件。

(2).如何導包
格式：import 包名;
導入包下面所有的文件:import 包名.*;//*是一個通配符，表示所有。

6.常用的權限修飾符

(1).概述
private: 只能夠在本類中使用
public ：所有的包下面都可以訪問，權限訪問最大。
protect: 所有的包下面都可以訪問，但是只能夠在不同包下面的子類可以使用。
默認 : 本類和同一個包下面可以使用。

(2).權限修飾符在類上面的使用

修飾符：
權限修飾符：private，默認的，protected，public
狀態修飾符：static，final
抽象修飾符：abstract

類：
權限修飾符：默認修飾符，public
狀態修飾符：final
抽象修飾符：abstract

用的最多的就是：public

成員變量：
權限修飾符：private，默認的，protected，public
狀態修飾符：static，final

用的最多的就是：private

構造方法：
權限修飾符：private，默認的，protected，public

用的最多的就是：public

成員方法：
權限修飾符：private，默認的，protected，public
狀態修飾符：static，final
抽象修飾符：abstract

用的最多的就是：public

除此以外的組合規則：
成員變量：public static final
成員方法：public static
public abstract
public final

7.內部類

(1).內部類概述
所謂的內部類就是把類定義在其他類的內部，那麽我們把定義在其他類內部的這一個類就稱為是內部類。

(2).內部類的訪問特點
A:內部類可以直接訪問外部類的成員，包括私有；
B:外部類想要訪問內部類的內容，必須創建外部類對象去調用；

代碼:
public class Day22 {

private int a = 10;

//內部類
class Inner{
public void show(){
System.out.println("內部類訪問外部類成員:"+a);
}
}

//外部類訪問內部類創建對象訪問
public void Test(){
Inner inner = new Inner();
inner.show();
}
}


(3).內部類的分類
按照內部類定義的位置的不同，可以把內部類分為倆大類型:
在成員位置定義:成員內部類
在局部位置定義:局部內部類

代碼體現:
public class Day22 {

//成員內部類
class Inner{
}

public void Test(){
//局部內部類
class Inner2{
}
}
}


(4).成員內部類基本使用

A:如何直接訪問內部類的成員
外部類名.內部類名 對象名 = 外部類對象.內部類對象；

B:代碼體現
public class Day22 {
private int a = 10;

//成員內部類
class Inner{
public void show(){
System.out.println("成員內部類訪問外部類成員:"+a);
}
}

public static void main(String[] args) {
//訪問Inner裏面的show()方法
Day22.Inner in = new Day22().new Inner();
in.show();
}
}

(5).成員內部類的常見修飾符以及應用
A:概述:由於java是面向對象的程序語言，我們按照對象來實現程序的編程，那麽外部類就是一個大的物體，而內部類也是一個物體，如電腦和CPU
,如人的身體和心臟，那麽這一個時候，我們對象修飾內部類的時候就需要加一些限制的修飾符，如private,static等。

B:成員內部類的常見修飾符
private :為了保證內部類數據的安全性
static :為了方便訪問數據(直接使用類名來調用)
註意：靜態內部類訪問的外部類數據必須用靜態修飾。

C:代碼體現
class Outer {
private int num = 10;
private static int num2 = 100;

//內部類用靜態修飾是因為內部類可以看出是外部類的成員
public static class Inner {
public void show() {
//System.out.println(num);//只能夠訪問靜態的數據
System.out.println(num2);
}

public static void show2() {
//System.out.println(num);
System.out.println(num2);
}
}
}

class InnerClassDemo4 {
public static void main(String[] args) {
//使用內部類
// 限定的新靜態類
//Outer.Inner oi = new Outer().new Inner();
//oi.show();
//oi.show2();

//成員內部類被靜態修飾後的訪問方式是:
//格式：外部類名.內部類名 對象名 = new 外部類名.內部類名();
Outer.Inner oi = new Outer.Inner();
oi.show();
oi.show2();

//show2()的另一種調用方式，由於Inner是靜態內部類，那麽我們就可以直接使用類名.方法名的格式來調用
Outer.Inner.show2();
}
}

(6).常見面試題1

/*
面試題：
要求請填空分別輸出30，20，10。

註意：
1:內部類和外部類沒有繼承關系。
2:通過外部類名限定this對象
Outer.this
*/
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(num);
System.out.println(this.num);
//System.out.println(new Outer().num);
System.out.println(Outer.this.num);
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

(7).局部內部類
局部內部類
A:可以直接訪問外部類的成員
B:在局部位置，可以創建內部類對象，通過對象調用內部類方法，來使用局部內部類功能

面試題：
局部內部類訪問局部變量的註意事項?
A:局部內部類訪問局部變量必須用final修飾(加載順序以及消失順序)
B:為什麽呢?
局部變量是隨著方法的調用而調用，隨著調用完畢而消失。
而堆內存的內容並不會立即消失。所以，我們加final修飾。
加入final修飾後，這個變量就成了常量。既然是常量。你消失了。
我在內存中存儲的是數據20，所以，我還是有數據在使用。

代碼體現:
class Outer {
private int num = 10;

public void method() {
int num2 = 20;
final int num2 = 20;

class Inner {
public void show() {
System.out.println(num);
//從內部類中訪問本地變量num2; 需要被聲明為最終類型
System.out.println(num2);//20
}
}

//System.out.println(num2);

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

class InnerClassDemo5 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}

(8).匿名內部類[*****]
A:匿名內部類
就是內部類的簡化寫法。
B:前提：存在一個類或者接口
這裏的類可以是具體類也可以是抽象類。
C：格式：
new 類名或者接口名(){
重寫方法;
}
D:本質是什麽呢?
是一個繼承了該類或者實現了該接口的子類匿名對象。

代碼體現[****]:
//定義前提，定義一個接口
interface Inter {
public abstract void show();
}

//定義一個類
class Outer {
public void method() {
//這一個整體就是一個對象而已
new Inter() {
public void show() {
System.out.println("show");
}
};
}

//測試類
class InnerClassDemo6 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
//輸出結果為:空，因為盡管有輸出語句，但是並沒有調用這一個方法。

那麽如何調用裏面的show()方法讓其輸出?
new Inter() {
public void show() {
System.out.println("show");
}
}.show();


代碼體現2[*****]繼承或者是實現的類有多個方法的時候如何處理

//接口
interface Inter {
public abstract void show();
public abstract void show2();
}

class Outer {
public void method() {

//如果我是很多個方法，就很麻煩了
//那麽，我們有沒有改進的方案呢?把子類對象賦值給繼承的接口，然後創建的對象在去調用方法即可
Inter i = new Inter() { //多態
public void show() {
System.out.println("show");
}

public void show2() {
System.out.println("show2");
}
};

i.show();
i.show2();
}
}

class InnerClassDemo6 {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}

(9).匿名內部類在開發中的使用

代碼體現:

/*
匿名內部類在開發中的使用
*/
interface Person {
public abstract void study();
}

class PersonDemo {
//接口名作為形式參數
//其實這裏需要的不是接口，而是該接口的實現類的對象
public void method(Person p) {
p.study();
}
}

//使用方法1
//實現類
class Student implements Person {
public void study() {
System.out.println("好好學習,天天向上");
}
}

class InnerClassTest2 {
public static void main(String[] args) {
//測試
PersonDemo pd = new PersonDemo();
Person p = new Student();
pd.method(p);
System.out.println("--------------------");

//使用方法2
//匿名內部類在開發中的使用
//匿名內部類的本質是繼承類或者實現了接口的子類匿名對象
pd.method(new Person(){
public void study() {
System.out.println("好好學習,天天向上");
}
});
}
}

Java基礎_基礎語法知識10