JAVA根底之外部類

2017-01-13

　　　　成員外部類

　　　　部分外部類

　　　　匿名外部類

　　　　靜態外部類

　　　　　　在一個類的外部再創立一個類，成為外部類

　　　　　　1）在一個類中運用外部類，可以在外部類中直接存取所在類的公有屬性或辦法

 1 class Outer{
 2     //內部類Outer
 3     private int i = 111 ;//內部類公有變量
 4     class Inner{
 5         //外部類Inner
 6         private int j = 222 ;//外部類公有變量
 7         public void print(){
 8             System.out.println("內部類的公有屬性"+ i);
 9             System.out.println("外部類的公有屬性"+ j);
10         }
11     }
12 }
13 public class ClassDemo5 {
14     public static void main(String[] args) {
15         Outer o = new Outer() ;
16         Outer.Inner i = o.new Inner() ; 
17         i.print() ;
18     }    
19 }

　　　　　  2）外部類的實例化辦法

import 面向對象根底.Outer.Inner;　　
//第一種方式:導入import 面向對象根底.Outer.Inner;包

Outer.Inner i = o.new Inner() ;
 //第二種方式：內部類.外部類 對象名 = 內部類對象.new 外部類

　　　　     3）內部類訪問外部類

 1 class Fatch{
 2     //內部類Fatch
 3     public class Student{
 4         //外部類Student
 5         public void show(){
 6             //外部類show（）辦法
 7             System.out.println("外部類Student的show（）辦法");
 8         }
 9     }
10     public void print(){
11         /**
12          * 內部類不可以直接訪問外部類的屬性或辦法,
13          * 必需創立外部類對象才可以訪問
14          */
15         new Student().show() ;    //運用匿名對象實例化調用外部類的類成員
16         System.out.println("內部類Fatch的print（）辦法");
17     }
18 }
19 public class ClassDemo4 {
20     public static void main(String[] args) {
21         Fatch f = new Fatch() ;    //實例化內部類對象
22         f.print() ;    //調用內部類的print（）辦法
23     }
24 }

　　　　　　4）假如內部類和外部類具有相反的成員變量或辦法，外部類默許訪問自己的成員變量或辦法，假如要訪問內部類的成員變量，可以運用 this 關鍵字。

 1 class Outer1 {
 2     //內部類
 3     private int i = 10 ;//內部類公有變量
 4     class Inner1{
 5         //外部類
 6         private int i = 20 ;//外部類公有變量
 7         public void show(){
 8             //外部類辦法
 9             System.out.println("外部類的變量"+ this.i );//運用this關鍵字訪問外部類成員
10             System.out.println("內部類的變量"+ Outer1.this.i);//運用內部類名.this.變量名 來訪問內部類成員
11         }
12     }
13     public void print(){
14         new Inner1().show() ;    //調用外部類辦法
15     }
16 }
17 public class ClassDemo6 {
18     public static void main(String[] args) {
19         new Outer1().print() ;　　
20     }
21 
22 }

　　　　    •留意點：

　　　　　　　　　　»實例化外部類之前必需實例化內部類

　　　　　　　　　　»外部類可以隨意訪問他的內部類成員，但內部類不可以直接訪問外部類的類成員

　　　　　　　　　　»外部類可以被聲明為private 或 protected 權限的訪問

　　　　　　　　　　»外部類對象會依賴於內部類對象，除非曾經存在一個內部類對象，否則類中不會呈現外部類對象

　　　　　　外部類不只可以在類中停止定義，也可以在類的部分地位停止定義，例如在類的辦法或許恣意的作用域中都可以定義外部類

　　　　     1）在內部類的辦法中定義一個辦法外部類

 1 class Demo1{
 2     //內部類Demo
 3      final int I = 10 ;//內部類定義的常量
 4      public void show(){    //內部類的show（）辦法
 5          class Inne{        //辦法外部類
 6              int j = 20 ;    //辦法外部類變量
 7              private void inshow() {    //辦法外部類中的inshow（）辦法
 8                  System.out.println("內部類常量"+ I );
 9                  System.out.println("辦法外部類變量"+ j );
10             }
11          }
12          Inne in = new Inne()  ;    //實例化外部類對象
13          in.inshow() ;    //調用外部類辦法
14      }
15 }
16 public class ClassDemo7 {
17     public static void main(String[] args) {
18         Demo1 d = new Demo1() ;
19         d.show() ;
20     }
21 }

　　　　留意：假如辦法中的參數需求被傳遞出來，就必需把參數聲明成final類型

　　　　　　假如一個外部類被聲明為static,此外部類就稱為內部類　

　　　　　  1）靜態外部類可以經過（new 內部類名.外部類.外部類辦法名） ，來調用靜態外部類辦法

 1 class Outer2{
 2     //內部類
 3     private static String str = "張博傑" ;//內部類的靜態變量
 4     static class Inner2{
 5         //運用static聲明 的靜態外部類
 6         public void fun() {
 7             //靜態外部類辦法
 8             System.out.println("內部類的靜態變量"+" "+ str);
 9         }
10     }
11 }
12 public class ClassDemo8 {
13     public static void main(String[] args) {
14         new Outer2.Inner2().fun() ;
15         //靜態外部類可以運用new 內部類名.外部類.外部類辦法名 ，來調用靜態外部類辦法
16     }
17 }

　　　　　　　　　　匿名外部類也就是沒有名字的外部類,正由於沒有名字，所以匿名外部類只能運用一次，它通常用來簡化代碼編寫.運用匿名外部類還有個前提條件：必需承繼一個父類或完成一個接口

 　　　　　　　  1)匿名外部類的完成

 1 abstract class A2 {    //籠統類A2
 2     public abstract void eat() ;
 3 }
 4 public class ClassDemo9 {
 5     public static void main(String[] args) {
 6         /**
 7          * 假如A2這個籠統類只用一次，那麼就可一運用匿名外部類來完成
 8          */
 9         A2 a = new A2(){
10             public void eat(){
11                 System.out.println("我要吃飯");
12             }
13         } ;
14         a.eat() ;
15     }
16 }