內部類內容解析
內部類的區分
內部類分別有成員內部類、局部內部類、匿名內部類、靜態內部類，接下來將分別介紹。
成員內部類
- 就是位於外部類成員位置的類。與外部類的屬性、方法並列。
- 成員內部類作為外部類的成員，可以訪問外部類的私有成員或屬性。（即使將外部類聲明為private，但是對於處於其內部的內部類還是可見的。）
- 用成員內部類定義在外部類中不可訪問的屬性。這樣就在外部類中實現了比外部類的private還要小的訪問權限。
注意：內部類是一個編譯時的概念，一旦編譯成功，就會成為完全不同的兩類。對於一個名為outer的外部類和其內部定義的名為inner的內部類。編譯完成后出現outer.class和outer$inner.class兩類。
- 代碼例子
public class Demo1 {
innerclass in=new innerclass(); //在成員內部類所在的外類中實例化成員內部類
public void outf() {
in.inf(); //因為in是成員內部類的實例化，所以才可以調用
}
class innerclass{//成員內部類
int y=0;
public innerclass() {//成員內部類的構造方法
}
public void inf() {
System.out.println("內部類方法y="+y);
}
}
public static void main(String[] args) {
Demo1 iDemo1=new Demo1();
iDemo1.outf();
Demo1.innerclass j= iDemo1.new innerclass(); //非外部類位置成員內部類實例化的方法（即首先要實例化一個外部類）
Demo1.innerclass k=new Demo1().new innerclass(); //實例化外部類和構造內部類一起寫
j.inf();
}
}
- 作用
數據安全。如果我們的內部類不想輕易被任何人訪問，可以選擇使用private修飾內部類，這樣我們就無法通過創建對象的途徑來訪問，想要訪問只需要在外部類中定義一個public修飾的方法，間接調用。這樣做的好處就是，我們可以在這個public方法中增加一些判斷語句，起到數據安全的作用。
局部內部類
- 定義在一個方法或者一個作用域里面的類。
- 局部內部類中不可定義靜態變量，可以訪問外部類的局部變量(即方法內的變量)，但是變量必須是final的。
- 代碼例子
public class Demo2 {
public outinterface action(String x) {//要把這個類返回出去，就需要通過接口，因為內部類在外部作用域中不存在
class innerclass2 implements outinterface{
public innerclass2(String s) {
s = x;
System.out.println(s);
}
}
return new innerclass2("do");
}
public static void main(String[] args) {
Demo2 demo2=new Demo2();
demo2.action("局部內部類");
}
}
interface outinterface{ //專門用來給局部內部類做向上轉型的父接口的操作
}
局部內部類只能在所在的方法體作用域內進行實例化，而如果要在所在方法體返回該類，就要通過接口向上轉型的操作。（如同上處代碼）
2. 作用
在某些情況下，某些業務邏輯需要臨時處理，這些業務邏輯只在這里使用又可以封裝成一個類的話，而又沒必要重新建個文件，所以可以這寫一個局部內部類來處理。然后，在我的記憶中，java代理模式中有用到局部內部類，在方法中直接實現接口，返回代理對象，簡單而又方便。
靜態內部類
靜態字段的內部類，和靜態方法並列。
- 代碼例子
public class Demo3 {
static int x=100;
static class innerclass3 {
void action() {
x=1; //x必須是靜態字段
}
public static void main(String[] args) {
System.out.println("我是靜態內部類");
}
}
}
- 作用
提供調試作用。我將main方法寫在靜態內部類中，生成.class文件后，調試代碼在靜態內部類當中，當我刪除靜態內部類后，其他人仍然可以使用我的外部類。
匿名內部類
- 一個沒有名字的類，是內部類的簡化寫法。
- 本質：其實是繼承該類或者實現接口的子類匿名對象。
- 代碼例子
//代碼示例一
public class Demo4 {
public Outinterface2 action() {
return new Outinterface2() { //②
private int i = 0;
public int getvalue() {
return i;
}
};
}
}
interface Outinterface2 {
}
class innerclass2 implements Outinterface2{//①
private int i = 0;
public int getvalue() {
return i;
}
}
//代碼示例二
interface Inner {
public abstract void show();
}
class Outer {
public void method(){
new Inner() {
public void show() {
System.out.println("HelloWorld");
}
}.show();
}
}
class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
//如果匿名內部類中有多個方法又該如何調用呢？
Inter i = new Inner() { //多態，因為new Inner(){}代表的是接口的子類對象
public void show() {
System.out.println("HelloWorld");
}
};
上述代碼①和②的作用是相同的。由此也可以解釋一下匿名內部類的作用。
- 作用
我們在開發的時候，會看到抽象類，或者接口作為參數。而這個時候，實際需要的是一個子類對象。如果該方法僅僅調用一次，我們就可以使用匿名內部類的格式簡化。
為什么使用內部類
一、封裝性
作為一個類的編寫者，我們很顯然需要對這個類的使用訪問者的訪問權限做出一定的限制，我們需要將一些我們不願意讓別人看到的操作隱藏起來，如果我們的內部類不想輕易被任何人訪問，可以選擇使用private修飾內部類，這樣我們就無法通過創建對象的方法來訪問，想要訪問只需要在外部類中定義一個public修飾的方法，間接調用。
public interface Demo {
void show();
}
class Outer {
private class test implements Demo {
public void show() {
System.out.println("密碼備份文件");
}
}
public Demo getInner() {
return new test();
}
}
二、實現多繼承
我們之前的學習知道，java是不可以實現多繼承的，一次只能繼承一個類，我們學習接口的時候，有提到可以用接口來實現多繼承的效果，即一個接口有多個實現，但是這里也是有一點弊端的，那就是，一旦實現一個接口就必須實現里面的所有方法，有時候就會出現一些累贅，但是使用內部類可以很好的解決這些問題。
public class Demo1 {
public String name() {
return "BWH_Steven";
}
}
public class Demo2 {
public String email() {
return "xxx.@163.com";
}
}
public class MyDemo {
private class test1 extends Demo1 {
public String name() {
return super.name();
}
}
private class test2 extends Demo2 {
public String email() {
return super.email();
}
}
public String name() {
return new test1().name();
}
public String email() {
return new test2().email();
}
public static void main(String args[]) {
MyDemo md = new MyDemo();
System.out.println("我的姓名:" + md.name());
System.out.println("我的郵箱:" + md.email());
}
}
我們編寫了兩個待繼承的類Demo1和Demo2，在MyDemo類中書寫了兩個內部類，test1和test2兩者分別繼承了Demo1和Demo2類，這樣MyDemo中就間接的實現了多繼承。
三、用匿名內部類實現回調功能
我們用通俗講解就是說在Java中，通常就是編寫一個接口，然后你來實現這個接口，然后把這個接口的一個對象作以參數的形式傳到另一個程序方法中， 然后通過接口調用你的方法，匿名內部類就可以很好的展現了這一種回調功能。
public interface Demo {
void demoMethod();
}
public class MyDemo{
public test(Demo demo){
System.out.println("test method");
}
public static void main(String[] args) {
MyDemo md = new MyDemo();
//這里我們使用匿名內部類的方式將接口對象作為參數傳遞到test方法中去了
md.test(new Demo){
public void demoMethod(){
System.out.println("具體實現接口")
}
}
}
}
四、 解決繼承及實現接口出現同名方法的問題
編寫一個接口Demo
public interface Demo {
void test();
}
編寫一個類 MyDemo
public class MyDemo {
public void test() {
System.out.println("父類的test方法");
}
}
兩者的方法名字都是test，下面編寫一個測試類；
public class DemoTest extends MyDemo implements Demo {
public void test() {
}
}
這樣的話我就有點懵了，這樣如何區分這個方法是接口的還是繼承的，所以我們使用內部類解決這個問題
public class DemoTest extends MyDemo {
private class inner implements Demo {
public void test() {
System.out.println("接口的test方法");
}
}
public Demo getIn() {
return new inner();
}
public static void main(String[] args) {
//調用接口而來的test()方法
DemoTest dt = new DemoTest();
Demo d = dt.getIn();
d.test();
//調用繼承而來的test()方法
dt.test();
}
}
//運行結果
接口的test方法
父類的test方法