java 内部类整理学习

内部类

内部类介绍：

1、封装在内部，不允许同包中其他类访问该类，

2、内部类可以直接访问外部类的私有数据。

3、匿名内部类适合于创建那些仅需要一次使用的类。

内部类与外部类的区别：

1、内部类多了，private protect static 三个修饰符

2、非静态内部类不能有静态成员。

内部类的分类：

1、静态内部类

2、局部内部类

3、匿名内部类

4、非静态内部类（成员内部类）：是一种与成员、方法、构造器和初始化块相似的类成员，局部内部类和匿名内部类不是类成员。

成员内部类两种：静态内部类和非静态内部类。

内部类的使用在方法中创建实例，并使用方法和属性

详细介绍：

非静态内部类：

可以直接访问外部类的私有成员，因为非静态内部类就和成员一样，都是在外部类的内部，所以可以访问私有变量。

实际上非静态内部类对象里，保存了一个他所寄生外部类的对象的引用。

外部类不能访问内部类的属性，但可以实例化内部类之后访问。，

不允许在外部类的静态成员中直接使用非静态内部类，就是实例化的对象可以访问类，但是类不可以访问实例化的对象成员

public class asd {
public int a=12;
private int b=2;

private String ass="我是外部类的私有成员";
class as{
public void aaa(){
System.out.println(ass);
}
}
// public static void runn(){
// as jjjj=new as();//静态成员内部不能有非静态内部类
// }

public void run(){
as jj=new as();
jj.aaa();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
asd ppp=new asd();
ppp.run();
}
}

境外内部类：

如果是静态内部类，则该内部类就属于外部类本身，而不属于外部类的某个对象。根据静态成员不能访问非静态成员的规则，静态内部类内部不能访问外部类的实例成员，只能访问外部类的类成员。

非静态内部类寄生在外部类的实例中，静态内部类寄生在外部类的本身中。

可以用静态内部类来定义外部类的所有方法、属性、初始化块，但是外部类依然不能直接访问内部类的成员。

接口内的内部类只能是静态内部类。

在外部类以外使用内部类，权限降低一级

Outerclass.interclass varname

在外部类以外的地方创建非静态内部类的实力方法

Outerclass.new Innerconstructor();

out.in in=new out().new IN();

在外部类以外的地方使用静态内部类

staticout.staticin in=new staticout.staticin();

public class asd {

public int a=12;

private int b=2;

private String ass="我是外部类的私有成员";

class as{

public as(){

System.out.println("非静态内部类的构造函数");

}

public void aaa(){

System.out.println(ass);

}

}

static class aas{

public aas(){

System.out.println("静态内部类的构造方法");

}

}

// public static void runn(){

// as jjjj=new as();//静态成员内部不能有非静态内部类

// }

public void run(){//在外部类内使用非静态内部类

as jj=new as();

aas jjj=new aas();//在外部类内使用静态内部类

jj.aaa();

}

public static void main(String[] args) {

// TODO Auto-generated method stub

asd ppp=new asd();

ppp.run();

}

}

class call{

public call(){

System.out.println("构造函数");

}

asd.as l=new asd().new as();//调用非静态类

asd.aas lll= new asd.aas();//调用静态类

}

局部内部类：把一个类放在方法里定义，这个类就是一个局部内部类，局部内部类只在方法内有效，因其外部是方法，所以不能用static修饰。由于作用于太小，开发效率不高。

public static void main(String[] args) {

// TODO Auto-generated method stub

asd ppp=new asd();

ppp.run();

call ppp1=new call();

ppp1.goo();

}

}

class call{

public call(){

System.out.println("构造函数");

}

public void goo(){

class haha{

public int a=1;

}

haha kk=new haha();

int o=kk.a;

System.out.println(o);

}

asd.as l=new asd().new as();//调用非静态类

asd.aas lll= new asd.aas();//调用静态类

}

不过学过js的感觉挺顺的

匿名内部类：

匿名内部类只适合创建那种只需要使用一次的类，创建方法，创建匿名内部类时，会立即创建匿名内部类的实例。

创建格式：

new 实现接口（）|父类构造器（参数）{

//匿名内部类的类体部分

}

匿名内部类必须继承父类，或实现一个接口，最多只能一个。

匿名内部类不能是抽象类，没有构造函数（因为没有类名，但可以有初始化块）；

局部变量被匿名内部类访问，即有final修饰（默认）；

interface waiin{

public void onee();

public void oneee();

}

abstract class cc{

public int qwe=3333;

public cc(){

System.out.println("我是将被匿名内部类调用的抽象类");

}

}

public class asd {

public int a=12;

private int b=2;

private String ass="我是外部类的私有成员";

class as{

public as(){

System.out.println("非静态内部类的构造函数");

}

public void aaa(){

System.out.println(ass);

}

}

static class aas{

public aas(){

System.out.println("静态内部类的构造方法");

}

}

public void run(waiin o){//在外部类内使用非静态内部类

as jj=new as();

aas jjj=new aas();//在外部类内使用静态内部类

jj.aaa();

}

public static void main(String[] args) {

// TODO Auto-generated method stub

asd ppp=new asd();

call ppp1=new call();

ppp1.goo();

ppp.run(new waiin(){//用匿名内部类返回值

@Override

public void onee() {

// TODO Auto-generated method stub

System.out.println("匿名内部类的抽象方法实现");

}

@Override

public void oneee() {

// TODO Auto-generated method stub

System.out.println("匿名内部类的抽象方法实现");

}

});

new cc(){

{

System.out.println("直接使用匿名内部类");

}

};

}

}

class call{

public call(){

System.out.println("构造函数");

}

public void goo(){

class haha{

public int a=1;

}

haha kk=new haha();

int o=kk.a;

System.out.println(o);

}

asd.as l=new asd().new as();//调用非静态类

asd.aas lll= new asd.aas();//调用静态类

}