内部类：
将一个类定义在另一个类的里面，对里面那个类就成为内部类（内置类、嵌套类）。
内部类访问特点：
1 内部类可以直接访问外部类中的成员
2 外部类要访问内部类，必须建立内部类的对象
用法
一般用于类的设计
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。这时就把还有的事物定义成内部类来描述。
class Outer{
private int num=3;
class Inner{//使用内部类可以直接访问num
void show(){
System.out.print("show。。。。"+num);
}
}
public void method(){//通过创建方法去创建对象，访问内部类
Inner in = new Inner();
in.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
Outer out=new Outer();
out.method();
}
}
image.png
常见的格式：
class Outer{
private int num=3;
private static int num1=4;
class Inner{//使用内部类可以直接访问num
void show(){
System.out.println("show。。。。"+num);
}
}
static class Inner1{//使用内部类可以直接访问num
void show1(){
//System.out.println("show1。。。。"+num);//在主函数调用这条语句会运行出错 静态类只能访问静态成员 所以需在num前加上static
System.out.println("show1。。。。"+num1);//注意num和num1的区别
}
static void function(){//如果内部类中定义了静态成员，该内部类也必须是静态的
System.out.println("function。。。。");
}
}
public void method(){//通过创建方法去创建对象，访问内部类
Inner in = new Inner();
in.show();
}
}
public class InnerDemo {
public static void main(String[] args) {
Outer.Inner in=new Outer().new Inner();//这种方式很少见，有些情况下内部类通常会被封装起来private
in.show();
//如果内部类是一个静态的，就相当于一个外部类
Outer.Inner1 in1=new Outer.Inner1();
in1.show1();
//如果内部类是静态的，成员是静态的。
Outer.Inner1.function();//直接调用
}
}
image.png
内部类能直接访问外部类的成员。原因：
因为内部类持有外部类的引用。外部类名.this
class Outer{
int num=3;
class Inner{
int num=4;
void show(){
int num=5;
System.out.println(num);
System.out.println(this.num);
System.out.println(Inner.this.num);
System.out.println(Outer.this.num);
}
}
void method(){
new Inner().show();
}
}
public class InnerClass {
public static void main(String[] args) {
Outer out=new Outer();
out.method();
}
}
image.png
内部类也可以放在局部位置上。
//内部类在局部位置上只能访问局部中被final修饰的局部变量。
class Outer{
int num=3;
void method(){
final int x = 9;//从内部类中访问局部变量需要在变量前加final
class Inner{
void show(){
System.out.println("show..."+num);
System.out.println("show..."+x);
}
}
Inner in=new Inner();
in.show();
}
}
public class JuBuInner {
public static void main(String[] args) {
new Outer().method();
}
}
image.png
匿名内部类：
匿名内部类，就是内部类的简写模式。
必须有前提：
内部类必须继承或者实现一个外部类或者接口。
匿名内部类：其实就是一个匿名子类对象。
格式：new 父类or接口(){子类内容}
class Outer{
int num=4;
// class Inner extends Demo{
// void show(){
// System.out.print("show..."+num);
// }
// }
public void method(){
//new Inner().show();
new Demo(){//匿名内部类
void show(){
System.out.println("show......"+num);
}
}.show();
}
}
public class InnerClass {
public static void main(String[] args) {
new Outer().method();
}
}
image.png
应用：
interface Inter{
void show1();
void show2();
}
class Outer{
int num =4;
/*
class Inner implements Inter{
public void show1(){}
public void show2(){}
}*/
public void method(){
// Inner in=new Inner();
// in.show1();
// in.show2();
Inter in=new Inter(){
public void show1(){
System.out.println("show......"+num);
}
public void show2(){
System.out.println("show......"+num);
}
};
in.show1();
in.show2();
}
}
/*
常见的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个。
可以用匿名内部类作为实际参数进行传递
*/
public class YingYong {
public static void main(String[] args) {
new Outer().method();
show(new Inter(){
public void show1(){System.out.println("show......");}
public void show2(){System.out.println("show......");}
});
}
public static void show(Inter in){
in.show1();
in.show2();
}
}
image.png
注意：
1 若在主函数中使用匿名内部类，因为主函数是静态的,只能调用静态的，所以想调用需用static修饰。
2 直接用例子解释：
class Outer{
void method(){
Object obj=new Object(){
public void show(){
System.out.print("show");
}
};
obj.show();//因为匿名内部类这个子类对象被向上转型为了Object类型
//这样就不能再使用子类特有的方法了。
//所以在这里运行出错
}
}
public class InnerDemo {
public static void main(String[] args) {
new Outer().method();
}
}
运行出错。
网友评论