内部类不是很好理解,但说白了其实也就是一个类中还包含着另外一个类
如同一个人是由大脑、肢体、器官等身体结果组成,而内部类相当于其中的某个器官之一,例如心脏:它也有自己的属性和行为(血液、跳动)
显然,此处不能单方面用属性或者方法表示一个心脏,而需要一个类
而心脏又在人体当中,正如同是内部类在外部内当中
java内部类分为: 成员内部类、静态嵌套类、方法内部类、匿名内部类 。
1内部类的共性
(1)、内部类仍然是一个独立的类,在编译之后内部类会被编译成独立的.class文件,但是前面冠以外部类的类名和$符号 。
(2)、内部类不能用普通的方式访问。内部类是外部类的一个成员,因此内部类可以自由地访问外部类的成员变量,无论是否是private的 。
(3)、内部类声明成静态的,就不能随便的访问外部类的成员变量了,此时内部类只能访问外部类的静态成员变量 。
1内部类的作用
内部类其实严重破坏了良好的代码结构,但为什么还要使用内部类呢?
因为内部类可以随意使用外部类的成员变量(包括私有)而不用生成外部类的对象,这也是内部类的唯一优点
如同心脏可以直接访问身体的血液,而不是通过医生来抽血。为了加深对Java内部类的理解,多想想内部类与外部类之间怎么转换的写法,我们可以体会出,写内部类会方便很多。
1内部类实例
package 内部类异常包装器;
/**
*
* TODO 成员内部类
*
* @author qiqitrue
* @version 1.0
* @since 2014-6-16
*/
public class MemberOuter {
private static int i;//静态成员变量
private int j = 10;
private int k =20;
public static void outer_f1(){
System.out.println("内部使用外部outer_f1()方法");
}//定义一个外部的静态方法
public void outer_f2(){
System.out.println("内部使用外部outer_f2()方法");
}
class Inner{
// static int inner_i = 100;//内部不允许定义静态变量
int j = 100;
int inner_i =1;
int k =10;
void inner_f1(){//内部类与外部类方法重名
System.out.println("可以直接访问外部类变量: "+i);//得到初始值0
System.out.println("在内部类中访问内部类的变量直接用变量名(也可以用this.j): "+j);
System.out.println("内部类使用外部类中与同类同名的实例变量用外部名.this.变量名"+MemberOuter.this.j);
System.out.println("内部类的k: "+k);//内部类变量
System.out.println("内部取外部类用"+MemberOuter.this.k); //取外部类则要外部类.this.变量名
outer_f1();//不需要外部类名.this
outer_f2();
}
}
public void outer_f3(){//外部类方法可以直接使用new对内部类的使用
System.err.println("进入outer_f3来取内部类方法成员");
Inner inner = new Inner();
inner.inner_f1();
}
public static void main(String[] args) {
//MemberOuter.Inner in = new MemberOuter().new Inner();
//in.inner_f1();
//注释可写成
MemberOuter m = new MemberOuter();
m.outer_f3();
}
}
package 内部类异常包装器;
/**
*
* TODO 成员内部类
*
* @author qiqitrue
* @version 1.0
* @since 2014-6-16
*/
public class MemberOuter {
private static int i;//静态成员变量
private int j = 10;
private int k =20;
public static void outer_f1(){
System.out.println("内部使用外部outer_f1()方法");
}//定义一个外部的静态方法
public void outer_f2(){
System.out.println("内部使用外部outer_f2()方法");
}
class Inner{
// static int inner_i = 100;//内部不允许定义静态变量
int j = 100;
int inner_i =1;
int k =10;
void inner_f1(){//内部类与外部类方法重名
System.out.println("可以直接访问外部类变量: "+i);//得到初始值0
System.out.println("在内部类中访问内部类的变量直接用变量名(也可以用this.j): "+j);
System.out.println("内部类使用外部类中与同类同名的实例变量用外部名.this.变量名"+MemberOuter.this.j);
System.out.println("内部类的k: "+k);//内部类变量
System.out.println("内部取外部类用"+MemberOuter.this.k); //取外部类则要外部类.this.变量名
outer_f1();//不需要外部类名.this
outer_f2();
}
}
public void outer_f3(){//外部类方法可以直接使用new对内部类的使用
System.err.println("进入outer_f3来取内部类方法成员");
Inner inner = new Inner();
inner.inner_f1();
}
public static void main(String[] args) {
//MemberOuter.Inner in = new MemberOuter().new Inner();
//in.inner_f1();
//注释可写成
MemberOuter m = new MemberOuter();
m.outer_f3();
}
}
package 内部类异常包装器;
/**
*
* TODO 方法内部类:顾名思义,嵌套在方法里面的类
*
* @author qiqitrue
* @version 1.0
* @since 2014-6-16
*/
public class Out { //Out到MemberOuter为非静态成员内部类 -- Outer6开始为局部内部类
int i = 9;
public static void main(String[] args) {
new Out().new in().display();//外部类引用内部类方法 外部类实例.内部类实例.方法
}
class in{//内部类
public void display(){
System.out.println("内部类对this的引用(相当于一个外部类的引用): "+Out.this.i);//内部类调用.this.变量
}
}
}
package 内部类异常包装器;
/**
*
* TODO 方法内部类:顾名思义,嵌套在方法里面的类
*
* @author qiqitrue
* @version 1.0
* @since 2014-6-16
*/
public class Out { //Out到MemberOuter为非静态成员内部类 -- Outer6开始为局部内部类
int i = 9;
public static void main(String[] args) {
new Out().new in().display();//外部类引用内部类方法 外部类实例.内部类实例.方法
}
class in{//内部类
public void display(){
System.out.println("内部类对this的引用(相当于一个外部类的引用): "+Out.this.i);//内部类调用.this.变量
}
}
}
package 内部类异常包装器;
/**
*
* TODO 成员内部类2
*
* @author qiqitrue
* @version 1.0
* @since 2014-6-16
*/
public class Outer1 {
private String name = "张三";
class Inner1{ //内部类
public void displayInner1(){
System.out.println(name+"非静态内部类Inner1的displayInner1方法,可以直接访问非静态外部类的私有属性name="+name);
}
}
public static void main(String[] args) {
new Outer1().new Inner1().displayInner1();//非静态内部类Inner1的displayInner1方法,可以直接访问非静态外部类的私有属性
}
}
package 内部类异常包装器;
/**
*
* TODO 成员内部类2
*
* @author qiqitrue
* @version 1.0
* @since 2014-6-16
*/
public class Outer1 {
private String name = "张三";
class Inner1{ //内部类
public void displayInner1(){
System.out.println(name+"非静态内部类Inner1的displayInner1方法,可以直接访问非静态外部类的私有属性name="+name);
}
}
public static void main(String[] args) {
new Outer1().new Inner1().displayInner1();//非静态内部类Inner1的displayInner1方法,可以直接访问非静态外部类的私有属性
}
}
package 内部类异常包装器;
public class Outer2 {
public static void main(String[] args) {
new Outer2().new Inner2().display();//对内部的调用
}
class Inner2{
private int age = 88;
public void display(){
System.out.println(age);//private私有在本类中可直接访问
System.out.println(this.age);//也可以通过this来访问
}
}
}
package 内部类异常包装器;
public class Outer2 {
public static void main(String[] args) {
new Outer2().new Inner2().display();//对内部的调用
}
class Inner2{
private int age = 88;
public void display(){
System.out.println(age);//private私有在本类中可直接访问
System.out.println(this.age);//也可以通过this来访问
}
}
}
package 内部类异常包装器;
public class Outer3 {
private int age = 98;
class Inner3{
private int age = 88;
public void display(){
System.out.println("内部类age: "+this.age);//内部类的成员访问
System.out.println("外部类age: "+Outer3.this.age);//内部使用外部类成员用外部类.this.成员
}
}
public static void main(String args[]){
new Outer3().new Inner3().display();
}
}
package 内部类异常包装器;
public class Outer3 {
private int age = 98;
class Inner3{
private int age = 88;
public void display(){
System.out.println("内部类age: "+this.age);//内部类的成员访问
System.out.println("外部类age: "+Outer3.this.age);//内部使用外部类成员用外部类.this.成员
}
}
public static void main(String args[]){
new Outer3().new Inner3().display();
}
}
package 内部类异常包装器;
public class Outer4 {
private char sex ='女';
class Inner4{
public void accessOuter(){
System.out.println(sex);
}
}
public static void main(String args[]){
//通过外部类对象的引用来访问内部类的对象 外部类名.内部类 实例对象 = new 外部类.new 内部类
Outer4.Inner4 in = new Outer4().new Inner4();
in.accessOuter();
}
}
package 内部类异常包装器;
public class Outer4 {
private char sex ='女';
class Inner4{
public void accessOuter(){
System.out.println(sex);
}
}
public static void main(String args[]){
//通过外部类对象的引用来访问内部类的对象 外部类名.内部类 实例对象 = new 外部类.new 内部类
Outer4.Inner4 in = new Outer4().new Inner4();
in.accessOuter();
}
}
package 内部类异常包装器;
public class Outer6 {
private int size=10;
public static void main(String[] args) {
Outer6 o = new Outer6();
o.display();
}
public void display(){
class Inner6{
private int size;
public void doStuff(int size){//构造有参数的方法
int a = size++;//传入的size
int b = this.size++;//局部内部类成员,在本类中的private size初始值为0
int c = Outer6.this.size++;//外部类成员
System.out.println(a+"\t"+b+"\t"+c);
}
}
new Inner6().doStuff(2);//对局部内部类的使用
}
}
package 内部类异常包装器;
public class Outer6 {
private int size=10;
public static void main(String[] args) {
Outer6 o = new Outer6();
o.display();
}
public void display(){
class Inner6{
private int size;
public void doStuff(int size){//构造有参数的方法
int a = size++;//传入的size
int b = this.size++;//局部内部类成员,在本类中的private size初始值为0
int c = Outer6.this.size++;//外部类成员
System.out.println(a+"\t"+b+"\t"+c);
}
}
new Inner6().doStuff(2);//对局部内部类的使用
}
}
package 内部类异常包装器;
public class Outer7 {
String str = new String("Bettween");//String类的方法 = String str = "Bettween";
String str2 = "abc";
public void amethod(final int iArgs){//局部内部类中访问外部类的局部变量,此变量必须是final修饰
int it= 0;
class Bicycle{
public void sayHello(){
System.out.println(str);//访问受静态static影响
System.out.println(iArgs);
// System.out.println(Outer7.this.it);
}
}
new Bicycle().sayHello();//在类的外部使用实例化来调用内部类的方法
}
public static void main(String[] args) {
new Outer7().amethod(2);
}
}
package 内部类异常包装器;
public class Outer7 {
String str = new String("Bettween");//String类的方法 = String str = "Bettween";
String str2 = "abc";
public void amethod(final int iArgs){//局部内部类中访问外部类的局部变量,此变量必须是final修饰
int it= 0;
class Bicycle{
public void sayHello(){
System.out.println(str);//访问受静态static影响
System.out.println(iArgs);
// System.out.println(Outer7.this.it);
}
}
new Bicycle().sayHello();//在类的外部使用实例化来调用内部类的方法
}
public static void main(String[] args) {
new Outer7().amethod(2);
}
}