Java修饰符、内部类（成员内部类、局部内部类、匿名内部类）、类中定义接口

最新推荐文章于 2024-03-24 10:48:32 发布

原创最新推荐文章于 2024-03-24 10:48:32 发布 · 791 阅读

4 ·

CC 4.0 BY-SA版权

Java基础专栏收录该内容

27 篇文章

订阅专栏

本文深入解析Java的权限修饰符、内部类的定义及访问特性，涵盖成员内部类、局部内部类、匿名内部类的概念与应用，以及类中定义接口的实践案例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Java权限修饰符、内部类、类中定义接口

一、四种权限修饰符

private(私有的) , 默认 , protected(受保护的) , public(公共的)

			本类	同一个包下(子类和无关类)  不同包下(子类) 不同包下(无关类)
private      Y		
默认         Y	           Y
protected	 Y		       Y		          Y
public		 Y		       Y		          Y		          Y

二、类及其组成所使用的常见修饰符

修饰符
- 权限修饰符：public、protected、默认、private
- 状态修饰符：static、final
- 抽象修饰符：abstract
修饰类的关键字
- 权限修饰符：默认修饰符，public
- 状态修饰符：final
- 抽象修饰符：abstract
修饰成员变量的关键字
- 权限修饰符：private、默认的、protected、public
- 状态修饰符：static，final
修饰成员变量的关键字
- 权限修饰符：private、默认的、protected、public
- 状态修饰符：static、final
修饰构造方法的关键字
- 权限修饰符：private、默认的、protected、public
修饰成员方法的关键字
- 权限修饰符：private、默认的、protected、public
- 状态修饰符：static、final
- 抽象修饰符：abstract
除此以外的组合规则
- 成员变量：public static final （接口）
- 成员方法：public static
  public abstract
  public final

三、内部类

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

案例

class 汽车 { //外部类
		class 发动机 { //内部类
	}
}

内部类访问特点

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

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

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
这是外部类的show方法
----------------
109
内部类的show方法
---------------
109
内部类的show方法

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

四、成员内部类

访问格式：外部类名.内部类名变量名 = 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();
}

成员内部类的修饰符

private 为了保证数据的安全性
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();
		}	
	}

五、局部内部类

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

定义格式

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

六、匿名内部类

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

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();
    }
}

七、类中定义接口

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