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 stubasd 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();//调用静态类
}