内部类、匿名内部类

布满荆棘的人生 2021-12-24 08:29 322阅读 0赞

# 内部类、匿名内部类 #

# 1.内部类 #

概述：把类定义在其他类的内部，这个类就被称为内部类

## 内部类访问特点 ##

1.内部类可以直接访问外部类成员，包括私有的

2.外部类要访问内部类成员，需先创建对象

public class Outer {
        int num = 10;
        private int a = 100;
        //定义成员内部类
        class Inner {
            int b = 109;
            public void innerShow() {
                System.out.println("内部类的show方法");
            }
            //内部类可以直接访问外部类的成员，包括私有
            public void innerTest(){
                System.out.println(num);
                System.out.println(a);
                outerShow();
                outerTest();
            }
        }
    
    public void outerShow() {
        System.out.println("这是外部类的show方法");
    }
    
    private void outerTest() {
        System.out.println("这是外部类的show方法");
    }
    //外部类，想要访问内部类的成员，得创建内部类的对象
    public void method(){
        //创建内部类的对象
        Inner inner = new Inner();
        System.out.println(inner.b);
        inner.innerShow();
    }
    
    }
    
    //测试类
    public class MyTest {
        public static void main(String[] args) {
            Outer outer = new Outer();
            System.out.println(outer.num);
            outer.outerShow();
            System.out.println("----------------");
            //使用成员内部类的属性和方法
            //创建成员内部类的语法
            Outer.Inner inner=new Outer().new Inner();
            System.out.println(inner.b);
            inner.innerShow();
            System.out.println("---------------");
            outer.method();
        }
    }
    
    //输出
    10

## 内部类分类 ##

成员位置:在成员位置定义的类，被称为成员内部类  
局部位置:在局部位置定义的类，被称为局部内部类  
四、成员内部类

访问格式：外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

案例
    
    //定义类
    class Body {
    //外部类，身体
    	private boolean life= true;
        //生命状态
         public class Heart { 
         //内部类，心脏
    	public void jump() {
             System.out.println("心脏噗通噗通的跳")
    			System.out.println("生命状态" + life); //访问外部类成员变量
    		}
    	}
    }
    
    //访问内部类
    public static void main(String[] args) {
    	//创建内部类对象
    	Body.Heart bh = new Body().new Heart();
    	//调用内部类中的方法
    	bh.jump();
    }

## 2.成员内部类的修饰符 ##

1.private 为了保证数据的安全性  
2.static 为了方便访问数据

注意：静态内部类访问的外部类数据必须用静态修饰，成员方法可以是静态的也可以是非静态的

面试题

class Outer {
    	public int num = 10;
    	class Inner {
    		public int num = 20;
    		public void show() {
    			int num = 30;
    			System.out.println(num); //30
    			System.out.println(this.num); //20
    			System.out.println(new Outer().num); //10
    		}
    	}
    }
    class InnerClassTest {
    	public static void main(String[] args) {
    		Outer.Inner oi = new Outer().new Inner();
    		oi.show();
    	}	
    }

# 3、局部内部类 #

局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

定义格式  
class 外部类 \{  
修饰符 返回值类型 方法名(参数) \{  
class 内部类 \{  
//其他代码  
\}  
\}  
\}  
访问方式

在外部类方法中，创建内部类对象，进行访问

案例
    
    public class MyTest {
        public static void main(String[] args) {
        	}
    
    }
    
    class Wai {
        int b = 100;//成员变量
        public void show(final int a) {
            //局部变量
            final int num = 10;
            class Nei {
                public void neiShow() {
                    //局部内部类，访问外部类的局部变量，局部变量必须加上final修饰，JDK1.8 默认就加上了
                    System.out.println(num);
                    System.out.println(a);
                }
            }
            //必须在外部类方法中创建内部类对象调用
            Nei n = new Nei();
            n.neiShow();
        }
    }
    //输出：
    10
    123

# 4、匿名内部类 #

匿名内部类的作用：临时定义某一指定类型的子类 ，定义后即刻创建刚刚定义的这个子类的对象

格式：

new 父类或接口()\{

//进行方法重写

\};

案例

public static void main(String[] args) {
        //匿名内部类：是局部内部类的简写
        //匿名内部类，本质上是一个对象，是谁的对象，是实现了该接口或继承了该抽象类的子类对象
        new AA(){
            @Override
            public void show() {
                System.out.println("重写了show方法");
            }
        }.show();
    
    }
    
    }
    
    abstract class AA{
        public abstract void show();
    }
    //输出：重写了show方法

### 匿名内部类中this关键字 ###

//要求在控制台输出”HelloWorld”
    interface Inter {
    	public static final int a = 23 ;
    }
    
    public class Test {
    
    	public static void main(String[] args) {
    		new Inter() {
    			public void show() {
    			// 这个this表示的是匿名内部类的这个对象
    				System.out.println(this.a);
    			}
    		}.show();
    	}
    }//输出：23
    
    匿名内部类面试题interface Inter1 {
        void show();
    }
    class Outer {
        //补齐代码
        //返回值是一个对象
        public static Inter1 method(){
            Inter1 in = new Inter1() {
                @Override
                public void show() {
                    System.out.println("Helloworld");
                }
            };
            return in;
        }
    }
    class OuterDemo {
        public static void main(String[] args) {
        //链式代码需返回值是一个对象
            Outer.method().show();
        }
    }

# 5、类中定义接口 #

public class MyTest {
        public static void main(String[] args) {
            //间接方式
            Outer outer = new Outer();
            outer.waiShow();
            //直接方式
    
        new Outer.Inner() {
            @Override
            public void show() {
                System.out.println("重写了接口中的show方法2");
            }
        }.show();
    
        Outer.Inner inner= new Outer.Inner() {
            @Override
            public void show() {
                System.out.println("重写了接口中的show方法3");
            }
        };
        inner.show();
    }
    
    }
    
    class Outer{
        //成员内部接口
        interface Inner{
            void show();
        }
    
    public void waiShow(){
        new Inner(){
            @Override
            public void show() {
                System.out.println("重写了接口中的show方法1");
            }
        }.show();
    
    }
    
    }
    //输出：
    重写了接口中的show方法1
    重写了接口中的show方法2
    重写了接口中的show方法3