java中的內部類
Ⅰ 在java中什麼是內部類
內部類就是寫在類中或方法中的類,它還是一個類,與其他類的不同就是他只為這個外部類(包含內部類的類)類所用
Ⅱ java裡面的內部類和外部類是什麼_
外部類:
最普通的,我們平時見到的那種類,就是在一個後綴為.java的文件中,直接定義的類
內部類:
內部類,顧名思義,就是包含在外部類中的類,就叫做內部類。內部類有兩種,一種是靜態內部類,一種是非靜態內部類。
靜態內部類和非靜態內部類之間的區別主要如下:
1、內部原理的區別:
靜態內部類是屬於外部類的類成員,是一種靜態的成員,是屬於類的,就有點類似於private static Singleton instance = null;非靜態內部類,是屬於外部類的實例對象的一個實例成員,靜態類則是屬於所有外部共有的,也就是說,每個非靜態內部類,不是屬於外部類的,是屬於外部類的每一個實例的,創建非靜態內部類的實例以後,非靜態內部類實例,是必須跟一個外部類的實例進行關聯和有寄存關系的。
2、創建方式的區別:
創建靜態內部類的實例的時候,只要直接使用「外部類.內部類()」的方式,就可以,比如School.Teacher();創建非靜態內部類的實例的時候,必須要先創建一個外部類的實例,然後通過外部類的實例,再來創建內部類的實例,new School().Teacher()
通常來說,我們一般都會為了方便,會選擇使用靜態內部類。
Ⅲ Java內部類有幾種
Java中的幾種內部類:
成員內部類:作為外部類的一個成員存在,與外部類的屬性、方法並列。當某個類除了他的外部類,不會被其他類使用時應該選擇使用成員內部類。
局部內部類:局部內部類定義在外部類的某個代碼塊或方法塊中。如果只會在某個方法或塊中創建這個類的對象,就可以使用局部內部類。
匿名內部類:匿名內部類一般定義在需要傳遞介面或回調的的地方,一個匿名內部類一定是在new的後面,用其隱含實現一個介面或繼承一個類。假如只需要創建這個類的一個對象不需要知道其實際類型(不需要使用到類名),那麼就可以使用匿名內部類。
靜態內部類:和成員內部類一樣,作為外部類的一個成員存在,與外部類的屬性、方法並列,只不過在聲明類的時候加入了static關鍵字。有時候,使用內部類只是為了把一個類隱藏在另外一個類的內部,並不需要內部類引用外圍類對象。這時可以使用靜態內部類,以便取消產生對外部類的引用。
Ⅳ Java 靜態內部類作用
1、變值許可權修飾作用,在定義內部類的時候,可以在其前面加上一個許可權修飾符static。此時這個內部類就變為了靜態內部類。
2、在某些特殊的情況下,少了這個靜態內部類還真是不行。如在進行代碼程序測試的時候,如果在每一個Java源文件中都設置一個主方法(主方法是某個應用程序的入口,必須具有),那麼會出現很多額外的代碼。
3、最主要的時這段主程序的代碼對於Java文件來說,只是一個形式,其本身並不需要這種主方法。但是少了這個主方法又是萬萬不行的。在這種情況下,就可以將主方法寫入到靜態內部類中,從而不用為每個Java源文件都設置一個類似的主方法。
這對於代碼測試是非常有用的。在一些中大型的應用程序開發中,則是一個常用的技術手段。
(4)java中的內部類擴展閱讀
例如:
對於兩個類,擁有相同的方法:
class People{
run();
}
interface Machine{
run();
}
此時有一個robot類:
class Robot extends People implement Machine.
此時run()不可直接實現。
interface Machine{
void run();
}
class Person{
void run(){
System.out.println("run");
}
}
class Robot extends Person{
private class MachineHeart implements Machine{
public void run(){
System.out.println("heart run");
}
}
public void run(){
System.out.println("Robot run");
}
Machine.getMachine(){returnnew MachineHeart();
}
class Test{
publicstaticvoid main(String[] args){
Robot robot=new Robot();
Machine m=robot.getMachine();
m.run();
robot.run();
}
}
Ⅳ java中內部類該何時用,怎麼用
1.在一個類內部還存在另一個類,則後者為內部類;
2.內部類可聲明成public或private,當內部類聲明成public或private時,對其訪問的限制與成員變數和成員方法完全相同;
3.定義格式:
標識符 class 外部類的名稱{
//外部類的成員
標識符 class 內部類的名稱{
//內部類的成員
}
}
示例:
class Outer{ // 定義外部類
private String info = "hello world" ; // 定義外部類的私有屬性
class Inner{ // 定義內部類
public void print(){ // 定義內部類的方法
System.out.println(info) ; // 直接訪問外部類的私有屬性
}
};
public void fun(){ // 定義外部類的方法
new Inner().print() ; // 通過內部類的實例化對象調用方法
}
};
public class InnerClassDemo01{
public static void main(String args[]){
new Outer().fun() ; // 調用外部類的fun()方法
}
};
這位童鞋可以試著不用內部類寫個程序完成以上功能,你會發現代碼明顯比之前的更加麻煩和復雜,所以內部類的唯一好處是方便的訪問外部類中的私有屬性,從而減少代碼。
Ⅵ Java里什麼叫內部類什麼叫外部類
對普通類(沒有內部類的類)來說,內部類和外部類都與他無關;對有內部類的類來說,它們就是其內部類的外部類,外部類是個相對的說法,其實就是有內部類的類。
所以,要回答這個問題,只需要講解內部類是什麼:
Java中的內部類共分為四種:
靜態內部類static inner class (also called nested class)
成員內部類member inner class
局部內部類local inner class
匿名內部類anonymous inner class
靜態內部類Static Inner Class
最簡單的內部類形式。
類定義時加上static關鍵字。
不能和外部類有相同的名字。
被編譯成一個完全獨立的.class文件,名稱為OuterClass$InnerClass.class的形式。
只可以訪問外部類的靜態成員和靜態方法,包括了私有的靜態成員和方法。
生成靜態內部類對象的方式為:
OuterClass.InnerClass inner = new OuterClass.InnerClass();
示例代碼:
package com.learnjava.innerclass;
class StaticInner
{
private static int a = 4;
// 靜態內部類
public static class Inner
{
public void test()
{
// 靜態內部類可以訪問外部類的靜態成員
// 並且它只能訪問靜態的
System.out.println(a);
}
}
}
public class StaticInnerClassTest
{
public static void main(String[] args)
{
StaticInner.Inner inner = new StaticInner.Inner();
inner.test();
}
}
成員內部類Member Inner Class
成員內部類也是定義在另一個類中,但是定義時不用static修飾。
成員內部類和靜態內部類可以類比為非靜態的成員變數和靜態的成員變數。
成員內部類就像一個實例變數。
它可以訪問它的外部類的所有成員變數和方法,不管是靜態的還是非靜態的都可以。
在外部類裡面創建成員內部類的實例:
this.new Innerclass();
在外部類之外創建內部類的實例:
(new Outerclass()).new Innerclass();
在內部類里訪問外部類的成員:
Outerclass.this.member
示例代碼:
package com.learnjava.innerclass;
class MemberInner
{
private int d = 1;
private int a = 2;
// 定義一個成員內部類
public class Inner2
{
private int a = 8;
public void doSomething()
{
// 直接訪問外部類對象
System.out.println(d);
System.out.println(a);// 直接訪問a,則訪問的是內部類里的a
// 如何訪問到外部類里的a呢?
System.out.println(MemberInner.this.a);
}
}
}
public class MemberInnerClassTest
{
public static void main(String[] args)
{
// 創建成員內部類的對象
// 需要先創建外部類的實例
MemberInner.Inner2 inner = new MemberInner().new Inner2();
inner.doSomething();
}
}
局部內部類Local Inner Class
局部內部類定義在方法中,比方法的范圍還小。是內部類中最少用到的一種類型。
像局部變數一樣,不能被public, protected, private和static修飾。
只能訪問方法中定義的final類型的局部變數。
局部內部類在方法中定義,所以只能在方法中使用,即只能在方法當中生成局部內部類的實例並且調用其方法。
示例代碼:
package com.learnjava.innerclass;
class LocalInner
{
int a = 1;
public void doSomething()
{
int b = 2;
final int c = 3;
// 定義一個局部內部類
class Inner3
{
public void test()
{
System.out.println("Hello World");
System.out.println(a);
// 不可以訪問非final的局部變數
// error: Cannot refer to a non-final variable b inside an inner
// class defined in a different method
// System.out.println(b);
// 可以訪問final變數
System.out.println(c);
}
}
// 創建局部內部類的實例並調用方法
new Inner3().test();
}
}
public class LocalInnerClassTest
{
public static void main(String[] args)
{
// 創建外部類對象
LocalInner inner = new LocalInner();
// 調用外部類的方法
inner.doSomething();
}
}
匿名內部類Anonymous Inner Class
匿名內部類就是沒有名字的局部內部類,不使用關鍵字class, extends, implements, 沒有構造方法。
匿名內部類隱式地繼承了一個父類或者實現了一個介面。
匿名內部類使用得比較多,通常是作為一個方法參數。
生成的.class文件中,匿名類會生成OuterClass$1.class文件,數字根據是第幾個匿名類而類推。
示例代碼:
package com.learnjava.innerclass;
import java.util.Date;
public class AnonymouseInnerClass
{
@SuppressWarnings("deprecation")
public String getDate(Date date)
{
return date.toLocaleString();
}
public static void main(String[] args)
{
AnonymouseInnerClass test = new AnonymouseInnerClass();
// 列印日期:
String str = test.getDate(new Date());
System.out.println(str);
System.out.println("----------------");
// 使用匿名內部類
String str2 = test.getDate(new Date()
{
});// 使用了花括弧,但是不填入內容,執行結果和上面的完全一致
// 生成了一個繼承了Date類的子類的對象
System.out.println(str2);
System.out.println("----------------");
// 使用匿名內部類,並且重寫父類中的方法
String str3 = test.getDate(new Date()
{
// 重寫父類中的方法
@Override
@Deprecated
public String toLocaleString()
{
return "Hello: " + super.toLocaleString();
}
});
System.out.println(str3);
}
}
Ⅶ java 中什麼是內部類啊麻煩給講解一下。謝謝!
樓上真牛...貼這么多...
簡單的說,內部類就是類中的類,舉個例子:
class A {
private int i;
private void m() {
}
class B {
mm(int j) {
i = j;
m();
}
}
}
這里,B就是A的內部類
內部類的特點就是,可以方便的訪問外部類裡面的私有方法和屬性,比如,這里B裡面可以直接訪問A裡面的私有屬性i,和私有方法m()
Ⅷ java中內部類
在java語言中,有一種類叫做內部類(inner class),也稱為嵌入類(nested class),它是定義在其他類的內部。內部類作為其外部類的一個成員,與其他成員一樣,可以直接訪問其外部類的數據和方法。只不過相比較外部類只有public和默認的修飾符不同,內部類作為一個成員,可以被任意修飾符修飾。編譯器在編譯時,內部類的名稱為OuterClass$InnerClass.class 。
1、內部類訪問數據變數
當在某些時候,內部類中定義的變數與外部類中變數名稱相同時,如何確保正確地訪問每一個變數呢?
1.1在main中直接從外部類調用內部類的方法
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(this); // the object created from the Inner
System.out.println(Outer.this); // the object created from the Outer
System.out.println(index); // output is 30
System.out.println(this.index); // output is 20
System.out.println(Outer.this.index); // output is 10
}
}
void print()
{
Inner inner = new Inner();//得到內部類的引用
inner.print();
}
}
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
outer.print();
}
}
在這里內部類Inner中關鍵字this指向內部類Inner的對象,如果要想指向外部類的對象,必須在this指針前加上外部類名稱,表示this是指向外部類構造的碎屑,如Outer.this 。
1.2在main中顯式返回內部類引用
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
}
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.getInner();
inner.print();
}
}
Inner是Outer的內部類,所以在類Test中必須用屬性引用符來標識出內部類。
1.3當main方法在Outer類內部
class Outer
{
private int index = 10;
class Inner
{
private int index = 20;
void print()
{
int index = 30;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
Inner getInner()
{
return new Inner();//返回一個內部類的引用
}
public static void main(String[] args)
{
Outer outer = new Outer();
Inner inner = outer.getInner(); // 注意此處變化
inner.print();
}
}
因為main方法在Outer內部,故可以直接引用,不需要屬性引用符。
1.4在main方法中直接產生內部類對象
class Test
{
public static void main(String[] args)
{
Outer outer = new Outer();
Outer.Inner inner = outer.new Inner(); // 注意此處變化
inner.print();
}
}
在利用new構造方法構造一個外部類對象時,並沒有連帶著構造一個內部類對象,故需要訪問內部類方法時,必須使用new操作符為這個外部類對象再構造一個內部類對象。
2、局部內部類
在方法中定義的內部類是局部內部類,它只能訪問方法中的final類型的局部變數,因為用final定義的局部變數相當於是一個常量,延長了其生命周期,使得方法在消亡時,其內部類仍可以訪問該變數。另外,它同樣也可以引用定義在外部類的變數和方法。而且方法體中的局部內部類不允許有訪問修飾符。
class Outer
{
int num=10;
public void print(final int aArgs)
{
class Inner
{
int num=20;
public Inner()
{
System.out.println("This is Inner.");//此句可看出它與匿名內部類用法的不同。
}
public void print()
{
int num=30;
System.out.println(this); // the object created from the local Inner
System.out.println(num);
System.out.println(this.num);
System.out.println(Outer.this.num);
System.out.println(aArgs);
}
}
Inner inner=new Inner();//此句必須放在定義類Inner的後面
inner.print();
}
public static void main(String[] args)
{
Outer outer=new Outer();
outer.print(40);
}
}
對於局部類的命名,不管是在一個方法中定義多個類還是在幾個方法中分別定義類,其編譯後命名是:OuterClass$1InnerClass.class
3、匿名內部類
匿名內部類作為一種特殊的內部類,除了具有普通內部類的特點,還有自己的一些獨有特性:
匿名內部類必須擴展一個基類或實現一個介面,但是不能有顯式的extends和implements子句;
匿名內部類必須實現父類以及介面中的所有抽象方法;
匿名內部類總是使用父類的無參構造方法來創建實例。如果是實現了一個介面,則其構造方法是Object();
匿名內部類編譯後的命名為:OuterClass$n.class,其中n是一個從1開始的整數,如果在一個類中定義了多個匿名內部類,則按照他們的出現順序從1開始排號。
abstract class A
{
abstract public void sayHello();
}
class Outer
{
public static void main(String[] args)
{
new Outer().callInner(new A()
{
public void sayHello()
{
System.out.println(this); // the object created from the anonymous Inner
System.out.println("Hello!");
}
});
}
public void callInner(A a)
{
a.sayHello();
}
}
4、靜態內部類
和非靜態內部類相比,區別就在於靜態內部類沒有了指向外部類的引用。除此之外,在任何非靜態內部類中,都不能有靜態數據,靜態方法或者又一個靜態內部類(內部類的嵌套可以不止一層)。不過靜態內部類中卻可以擁有這一切。這也算是兩者的第二個區別吧。一個靜態的內部類,才可以聲明一個static成員,靜態內部類可以訪問外圍類的靜態方法、成員(包括private static的成員)。靜態內部類實例化的時候不必先實例化外圍類,可以直接實例化內部類。而對於非靜態內部類則必須先實例化其外部類,才能再實例化本身。
5.內部類的繼承
當一個類繼承自一個內部類時,預設的構造器不可用。必須使用如下語法:
class WithInner
{
class Inner
{
public void sayHello()
{
System.out.println("Hello.");
}
}
}
public class Test extends WithInner.Inner
{
Test(WithInner wi)
{
wi.super();
}
public static void main(String[] args)
{
WithInner wi=new WithInner();
Test test=new Test(wi);
test.sayHello();
}
}
因為每一個內部類都有一個指向外部類的引用,在繼承一個內部類,必須先創建一個外部類,通過這個外部類引用來調用其內部類的構造方法。如果繼承的內部類是一個靜態內部類,則就不需要這樣,直接super()調用即可;
6、內部類的2種特殊用法
一個類從另一個類派生出來,又要實現一個介面。但在介面中定義的方法與父類中定義的方法的意義不同,則可以利用內部類來解決這個問題。
interface Machine
{
void run();
}
class Person
{
void run()
{
System.out.println("run");
}
}
class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run()
{
System.out.println("heart run");
}
}
Machine getMachine()
{
return new MachineHeart();
}
}
class Test
{
public static void main(String[] args)
{
Robot robot = new Robot();
Machine m = robot.getMachine();
m.run();
robot.run();
}
}
在Robot類內部使用內部類MachineHeart來實現介面Machine的run方法。同時Robot類又繼承了父類Person的run方法。如果不使用內部類MachineHeart而使Robot直接實現介面Machine,則該如何調用父類的run方法?
利用內部類可解決c++中多重繼承所解決的問題
class A
{
void fn1()
{
System.out.println("It' s fn1.");
}
}
abstract class B
{
abstract void fn2();
}
class C extends A
{
B getB()
{
return new B()
{
public void fn2()
{
System.out.println("It' s fn2.");
}
};
}
}
class Test
{
public static void main(String[] args)
{
C c = new C();
c.fn1();
c.getB().fn2();
}
}
類C既要繼承類A又要繼承類B,則可將類B的定義放入類C內部,使之成為內部類。
一般情況下 當我們需要在某一情形下實現一個介面,而在另一情形下又不需要實現這個介面時,我們可以使用內部類來解決這一問題。讓內部類來實現這個介面。另外一個很好的理由是java內部類加上介面可以有效地實現多重繼承。
Ⅸ 什麼是內部類內部類有什麼作用(java)
在Java中,可以將一個類定義在另一個類裡面或者一個方法裡面,這樣的類稱為內部類。廣泛意義上的內部類一般來說包括這四種:成員內部類、局部內部類、匿名內部類和靜態內部類。下面就先來了解一下這四種內部類的用法。
成員內部類是最普通的內部類,它的定義為位於另一個類的內部,形如下面的形式:
class Circle { double radius = 0; public Circle(double radius) { this.radius = radius; } class Draw { //內部類 public void drawSahpe() { System.out.println("drawshape"); } }}
這樣看起來,類Draw像是類Circle的一個成員,Circle稱為外部類。成員內部類可以無條件訪
class Circle { private double radius = 0; public static int count =1; public Circle(double radius) { this.radius = radius; } class Draw { //內部類 public void drawSahpe() { System.out.println(radius); //外部類的private成員 System.out.println(count); //外部類的靜態成員 } }}
不過要注意的是,當成員內部類擁有和外部類同名的成員變數或者方法時,會發生隱藏現象,即默認情況下訪問的是成員內部類的成員。如果要訪問外部類的同名成員,需要以下面的形式進行訪問:
外部類.this.成員變數外部類.this.成員方法
雖然成員內部類可以無條件地訪問外部類的成員,而外部類想訪問成員內部類的成員卻不是這么隨心所欲了。在外部類中如果要訪問成員內部類的成員,必須先創建一個成員內部類的對象,再通過指向這個對象的引用來訪問:
class Circle { private double radius = 0; public Circle(double radius) { this.radius = radius; getDrawInstance().drawSahpe(); //必須先創建成員內部類的對象,再進行訪問 } private Draw getDrawInstance() { return new Draw(); } class Draw { //內部類 public void drawSahpe() { System.out.println(radius); //外部類的private成員 } }}
成員內部類是依附外部類而存在的,也就是說,如果要創建成員內部類的對象,前提是必須存在一個外部類的對象。創建成員內部類對象的一般方式如下:
public class Test { public static void main(String[] args) { //第一種方式: Outter outter = new Outter(); Outter.Inner inner = outter.new Inner(); //必須通過Outter對象來創建 //第二種方式: Outter.Inner inner1 = outter.getInnerInstance(); }} class Outter { private Inner inner = null; public Outter() { } public Inner getInnerInstance() { if(inner == null) inner = new Inner(); return inner; } class Inner { public Inner() { } }}
內部類可以擁有private訪問許可權、protected訪問許可權、public訪問許可權及包訪問許可權。比如上面的例子,如果成員內部類Inner用private修飾,則只能在外部類的內部訪問,如果用public修飾,則任何地方都能訪問;如果用protected修飾,則只能在同一個包下或者繼承外部類的情況下訪問;如果是默認訪問許可權,則只能在同一個包下訪問。這一點和外部類有一點不一樣,外部類只能被public和包訪問兩種許可權修飾。我個人是這么理解的,由於成員內部類看起來像是外部類的一個成員,所以可以像類的成員一樣擁有多種許可權修飾。