- Java 内部类初学习
- 一、什么是内部类
- 二、成员内部类
- 【案例一】
- 【案例二】
- 三、局部内部类
- 【案例一】
- 四、匿名内部类
- 【案例一】
- 【案例二】
- 五、静态内部类
- 【案例一】
一、什么是内部类
在 Java 中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类
——菜鸟教程
内部类可以拥有 :
- private 访问权限（只能在外部类的内部访问）
- protected 访问权限（只能在同一个包下或者继承外部类的情况下访问）
- public 访问权限
- 包访问权限
- 默认访问权限（只能在同一个包下访问）
二、成员内部类
- 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
- 不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量 外部类.this.成员方法【案例一】
class Outter {
int y = 10;
public class Inner {
int y=5;
public int test() {
this.y=Outter.this.y;
return this.y;
}
}
}
public class main {
public static void main(String[] args) {
Outter outter=new Outter();
Outter.Inner inner = outter.new Inner();
System.out.println(outter.y);
System.out.println(inner.y);
inner.test();
System.out.println(inner.y);
}
}
输出：
10 5 10【案例二】
package com.kang.InnerClass;
//外部类Outter
class Outter {
private static String str="我是外部类的私有静态成员";
int x = 10;//外部类成员x
public class Inner {//内部类，访问权限为有public
int y = x-1;//内部类访问外部类成员
String s=str;
}
}
public class test {
public static void main(String[] args) {
Outter outter=new Outter();//创建外部类对象
Outter.Inner inner = outter.new Inner();//创建内部类对象
System.out.println(inner.y+outter.x);
System.out.println(inner.s);
}
}
输出：
19 我是外部类的私有静态成员三、局部内部类
-
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内
-
局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的
下面是引用的菜鸟教程里的一段代码：
class People{
public People() {
}
}
class Man{
public Man(){
}
public People getWoman(){
class Woman extends People{ //局部内部类
int age =0;
}
return new Woman();
}
}
四、匿名内部类
- 当一个内部类需要继承或者实现，而且只使用一次的时候，可以考虑使用匿名内部类。
- 调用的时候直接使用父类的无参构造，并重写父类方法
- 匿名内部类也是不能有访问修饰符和 static 修饰符的
package com.kang.Anonymous_Inner_Class;
public class Anonymous_Inner_Class{
interface HelloWorld {
public void greet();
public void greetSomeone(String someone);
}
public void sayHello() {
// 1、局部类EnglishGreeting实现了HelloWorld接口
class EnglishGreeting implements HelloWorld {
String name = "world";
public void greet() {
greetSomeone("world");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hello " + name);
}
}
HelloWorld englishGreeting = new EnglishGreeting();
// 2、匿名类实现HelloWorld接口
HelloWorld frenchGreeting = new HelloWorld() {
String name = "tout le monde";
public void greet() {
greetSomeone("tout le monde");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Salut " + name);
}
};
// 3、匿名类实现HelloWorld接口
HelloWorld spanishGreeting = new HelloWorld() {
String name = "mundo";
public void greet() {
greetSomeone("mundo");
}
public void greetSomeone(String someone) {
name = someone;
System.out.println("Hola, " + name);
}
};
englishGreeting.greet();
frenchGreeting.greetSomeone("Fred");
spanishGreeting.greet();
}
public static void main(String... args) {
Anonymous_Inner_Class myApp = new Anonymous_Inner_Class();
myApp.sayHello();
}
}
-
该例中用局部类来初始化变量englishGreeting，用匿名类来初始化变量frenchGreeting和spanishGreeting，两种实现之间有明显的区别：
-
局部类EnglishGreetin继承HelloWorld接口，有自己的类名，定义完成之后需要再用new关键字实例化才可以使用；
-
frenchGreeting、spanishGreeting在定义的时候就实例化了，定义完了就可以直接使用；
-
匿名类是一个表达式，因此在定义的最后用分号";"结束。
-
输出：
Hello world Salut Fred Hola, mundo【案例二】
public class AnimalTest {
private final String ANIMAL = "动物";
public void accessTest() {
System.out.println("匿名内部类访问其外部类方法");
}
class Animal {
private String name;
public Animal(String name) {
this.name = name;
}
public void printAnimalName() {
System.out.println(bird.name);
}
}
// 鸟类，匿名子类，继承自Animal类，可以覆写父类方法
Animal bird = new Animal("布谷鸟") {
@Override
public void printAnimalName() {
accessTest(); // 访问外部类成员
System.out.println(ANIMAL); // 访问外部类final修饰的变量
super.printAnimalName();
}
};
public void print() {
bird.printAnimalName();
}
public static void main(String[] args) {
AnimalTest animalTest = new AnimalTest();
animalTest.print();
}
}
输出：
运行结果： 匿名内部类访问其外部类方法 动物 布谷鸟五、静态内部类
- 静态内部类就是在成员内部类多加了一个 static 关键字。
- 静态内部类只能访问外部类的静态成员变量和方法（包括私有静态）
- 调用静态内部类的非静态方法和属性要用创建内部类的对象来调用
- 调用静态内部类的静态方法和属性可以直接用类名来调用
package com.kang.InnerClass;
class Outter_2 {//外部类Outter
private static String str="我是外部类的私有静态成员";
int x = 10;
static class Inner {//内部类，访问权限为public
//int y = x-1;//内部类访问外部类成员
String s=str;
static String s1=str;//内部类的静态成员
public static void a() {
System.out.println("4、这是静态内部类的静态方法");
}
}
}
public class static_test {
public static void main(String[] args) {
// Outter outter=new Outter();//创建外部类对象
Outter_2.Inner inner = new Outter_2.Inner();//创建内部类对象
// System.out.println(inner.y);
System.out.println("1、"+inner.s);//非静态方法需要new一个对象来调用
System.out.println("2、"+inner.s1);
System.out.println("3、"+Outter_2.Inner.s1);//直接通过类名来调用
inner.a();
Outter_2.Inner.a();//直接通过类名来调用
}
}
输出:
1、我是外部类的私有静态成员 2、我是外部类的私有静态成员 3、我是外部类的私有静态成员 4、这是静态内部类的静态方法 4、这是静态内部类的静态方法
