【JavaSE ⑥】P195 ~ P208 final关键词修饰类，方法，局部变量，成员变量；4种权限修饰符；成员内部类，局部内部类，局部内部类的final问题，匿名内部类；复习匿名对象

_esther_

已于 2024-04-09 10:12:56 修改

阅读量758

点赞数 27

分类专栏： Java语法文章标签： java 开发语言

于 2024-03-10 23:13:57 首次发布

本文链接：https://blog.csdn.net/qq_24990383/article/details/136424646

版权

Java语法专栏收录该内容

28 篇文章 2 订阅

订阅专栏

final 关键字

final 关键字代表最终、不可改变的。

常见四种用法：

可以用来修饰一个类
可以用来修饰一个方法
还可以用来修饰一个局部变量
还可以用来修饰一个成员变量

final修饰类

当final 关键字用来修饰一个类的时候，格式：

public final class 类名称{
	//……
}

含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没子类）

final修饰方法

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：

修饰符 final 返回值类型 方法名称(参数列表){
	// 方法体
}

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

final修饰局部变量

基本类型
a. 创建时直接赋值
b. 创建时不赋值，之后只赋值一次
引用类型
也如上两种赋值方式，赋对应类对象即可
final 修饰的对象，可改自身成员变量内容。内容可以改，对象地址值不可变

final修饰成员变量

对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变

由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
对于final 的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
必须保证类当中所有冲在的构造方法，都最终会对final的成员变量进行赋值。

● 练习

1.final关键字修饰几处，判断对错，改正分析

public final class MyClass/* extends Object*/{
	public void method(){
		System.out.println("方法执行！");
	}
}
public class MySubClass extends MyClass{
	@Override
	public void method(){
		System.out.println("重写方法执行！");
	}
}

public class Fu{
	public final void method(){
		System.out.println("父类方法执行！");
	}
}
public Zi extends Fu{
	@Override
	public void method(){
		System.out.println("子类覆盖重写父类的方法！");
	}
}

public abstract class Fu{
	public final void method();
	public final void method2(){
		System.out.println("父类方法执行");
	}
	public abstract final void methodAbs();
}

public static void main(String[] args){
	final int num2 = 200;
	num2 = 200;
	final int num3;
	num3 = 400;
	num3 = 500;
	System.out.println(num2);
	System.out.println(num3);
}

e. Student 是一个自定义类，有无参构造和全参构造Student（String name）两种构造器

final Student stu1 = new Student("张三");
System.out.println(stu1);
System.out.println(stu1.getName());
stu1.setName("王五");
System.out.println(stu1.getName());

stu1 = new Student("李四");
System.out.println(stu1);
System.out.println(stu1.getName());

public class Person{
	private final String name;
	public Person(){
		
	}
	public Person(String name){
		this.name = "张三";
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}
}

A:
a. final 修饰的类不可以作为父类被继承，包括其中的方法也不可能被重写。

 ● 错 public class MySubClass extends MyClass{
	@Override
	public void method(){
		System.out.println("重写方法执行！");
	}
}

b. final 修饰的方法，不可以被子类重写覆盖。此处如果不写@Override的话，默认public void method() 并不是重写，而且自己的新方法

public Zi extends Fu{
	 ● @Override
	 ● public void method(){
		System.out.println("子类覆盖重写父类的方法！");
	} 
}

c. ① final修饰的方法是普通方法，并不是抽象方法，所以必须有方法体；
②== abstract 和final不可以同时修饰一个方法。==因为抽象方法，实现类必须重写覆盖。但final代表最终，子类是不可以重写父类中final修饰的方法的！
两个关键字意义矛盾，不可以同时使用
复习：抽象类不一定有抽象方法。但有抽象方法的类一定是抽象类

public abstract class Fu{
	 ● public final void method();
	public final void method2(){
		System.out.println("父类方法执行");
	}
	 ● public abstract final void methodAbs();
}

d. final 修饰局部变量，因为局部变量没有默认值。所以一定要赋值一次。创建时赋值或创建好后赋值都可以。
① 已经赋值，不可以再赋值，值一样也不行。编译器不会闲到检测一下一不一样，只要二次赋值通通错误
② final修饰的变量只能赋值一次，二次赋值错误

public static void main(String[] args){
	final int num2 = 200;
	 ● num2 = 200;
	final int num3;
	num3 = 400;
	 ● num3 = 500;
	System.out.println(num2);
	System.out.println(num3);
}

e. final修饰对象，对象内容可以改变。但地址值不可以，必须保证还是原来的那个对象。

final Student stu1 = new Student("张三");
System.out.println(stu1);
System.out.println(stu1.getName());
stu1.setName("王五");//可以改变内容
System.out.println(stu1.getName());

 ● stu1 = new Student("李四"); //改为 Student stu2 = new Student("李四");
System.out.println(stu1);//打印地址与之前不同
System.out.println(stu1.getName());//内容正常显示，但并不是同一个对象

f. final修饰成员变量，因为成员变量有初始值，有两种赋值方式，① 创建时直接赋值。② 创建时不赋值，在所有构造器中分别赋值
跟局部变量的区别是，局部变量可以先创建再赋值。
final变量不能随意更改，没有对应的setter方法

public class Person{
	private final String name;
	 ● public Person(){	
	}
	//修改后
	public Person(){
		this.name = null;
	}
	public Person(String name){
		this.name = "张三";
	}
	public String getName(){
		return name;
	}
	 ● public void setName(String name){
		this.name = name;
	}
}

写法2

public class Person{
	private final String name = "张三";
	public Person(){
		;	
	}
	public Person(String name){
		;
	}
	public String getName(){
		return name;
	}
}

四种权限修饰符

在这里插入图片描述

● 练习

1. 判断对错改正

修改MyClass中的num和method权限修饰符分别为public，protected，（default）, private ，判断其他访问方式的正确与否

package code01;
public class MyClass {
//从public 到private,四个挨个换。
    [public] int num = 10;
    [public] void method(){
        System.out.println("MyClass方法执行");
    }
    /*判断点1，类内部*/
    public void test(){
        method();
        num = 20;
        System.out.println(num);
    }
}

判断点2，同包不同类

package code01;
public class MyAnother {
    public void test(){
        System.out.println("子类访问方法");
        MyClass c1 = new MyClass();
        System.out.println(c1.num);
        c1.method();
    }
}

判断点3 不同包子类

package code01.permissions;
import code01.MyClass;

public class MyZi extends MyClass {
    public void test(){
        System.out.println("子类访问方法");
        new MyClass().num = 30;
        System.out.println(super.num);
        super.method();
    }
}

判断点4 不同包陌生类（即不是子类）

package code01.permissions;
import code01.MyClass;

public class MainTest {
    public static void main(String[] args) {
        MyClass c1 = new MyClass();
        c1.method();
        System.out.println(c1.num);
    }
}

A: ① MyClass的num和method都为private 时。只允许类内部访问，判断点1 正确，2，3，4错误。访问method和num处报错
② 都为（default）时，即不写修饰符。比private多一个允许同包类访问，1,2处正确，3,4错误
③ 都为protected 时 比（default）多一个允许不同包但是子类里访问。判断点1,2，3正确，4错误。注意此处，判断点3第7行作物，作为不同包的子类访问父类protected修饰的成员时，应该使用super而不是new 父类对象，这样相当于不同包陌生类的写法，是不能访问protected类型成员的

package code01.permissions;
import code01.MyClass;

public class MyZi extends MyClass {
    public void test(){
        System.out.println("子类访问方法");
       //注意，如果子类也使用new MyClass访问，因为不同包，又不用super，相当于是陌生类访问了。
        //父类MyClass中的proctected类型成员，将无法在子类中访问。所以必须用super
         ● new MyClass().num = 30; 
        System.out.println(super.num);
        super.method();
    }
}

④ 都为public时，判断点1,2，3,4都正确。即如果不在一个包，只要导包了，哪个类都可以用num和method。

内部类

内部类的概念与分类

如果一个事物的内部包含另一个食物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。
分类：

成员内部类
局部内部类（包含匿名内部类）

成员内部类的定义

修饰符  class 外部类名称{
	修饰符 class 内部类名称{
		//……
	}
	//……
}

注意：内用外，随意访问；外用内，需要内部类对象
编译时，在包名或类名上右键选 Show in Explorer查看文件夹形式，再返回到项目名，找到.class文件
在这里插入图片描述

在菜单栏选择重新编译，菜单栏Build-> Recompile ‘Body.java’
在这里插入图片描述

可以看到内部类的.class文件格式是外部类名$内部类名.class
所以虽然命名规则中可以使用_和$但我们一般只使用_

成员内部类的使用

创建的成员内部类如下Heart

public class Body{

	public class Heart{
		//内部类的方法
		public void beat(){
			System.out.println("心跳");
			System.out.println("我叫：" + name);//正确写法！
		}
	}
	//外部类的成员变量
	private String name;
	public ine num;
	//外部类的方法
	public void methodBody(){
		System.out.println("外部类的方法");
		new Heart().beat();
	}

	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}
}

间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法

public class MainTest {
    public static void main(String[] args) {
		Body body = new Body();//外部类的对象
		//通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
		body.methodBody();
    }
}

直接方式：公式：外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();

对比普通对象创建：类名称对象名 = new 类名称();

public class MainTest {
    public static void main(String[] args) {
		Body.Heart obj1 = new Body("barbie", 18).new Heart();
        obj1.beat();
        System.out.println(obj1.num);
     }
}

内部类和外部类的同名变量访问

内部类方法访问重名变量
如果出现了重名现象，格式：外部类名称.this.外部类成员变量名

public class Outer{
	int num = 10;
	public class Inner{
		int num = 20;
		public void methodInner(){
			int num = 30;
			System.out.println(num);//局部变量，就近原则
			System.out.println(this.num);//内部类的成员变量
			System.out.println(Outer.this.num);//外部类的成员变量
		}
	}
}

外部类方法访问重名变量

public class Outer{
	int num = 10;
	public class Inner{
		int num = 20;
	}
	public void methodOuter(){
			int num = 30;
			System.out.println(num);//局部变量，就近原则
			System.out.println(this.num);//外部类的成员变量
			System.out.println(new Inner().num);//内部类的成员变量，在外部类中必须用内部类对象访问
	}
}

局部内部类定义

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。

格式：

修饰符 class 外部类名称{
	修饰符 返回值类型 外部类方法名称(参数列表){
		class 局部内部类名称{
			//……
		}
	}
}

例：

public class Outer{
	public void methodOuter(){
		class Inner{
			int num = 10;
			public void methodInner(){
				System.out.println(num);//10
			}
		}
		//在局部内部类所在的方法中调用，使用
		Inner inner = new Inner();
		inner.methodInner();
	}
}

public class DemoMain{
	public static void main(String[] args){
		Outer obj = new Outer();
		obj.methodOuter();
	}
}

定义类的时候，权限修饰符规则

局部内部类类似局部变量，不可以写权限修饰符。与（default）不同
外部类只可以用public/(default)
why?
可以把该外部类Outer暂且看成一个内部类,假设外部还有一个OutMax类，
①当Outer是private权限修饰时，Outer内部类只可以在OutMax类内部使用。但如果Outer已经是最外部类了，并没有“更外部的类”存在，private的使用区间也不存在，无意义。所以不可以用private
②当Outer是protected权限修饰时，比（default）代表的可以在同一个包的类中访问区间，多一个可以在“所在类的子类中访问”。but当Outer类是最外部的类，并不存在更外部的类OutMax，也没有OutMax的子类。protected无意义
③ public 指这个类在其他任何类，只要导包了都可以访问用
④（default）指这个外部类在同包类中可以访问

局部内部类的final问题

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
什么是有效final，就是事实final,final关键字可以省略，但赋值次数符合final要求。即只赋值一次，不可重复赋值
例：

public class MyOuter {
    public void methodOut(){
        int num = 10;
        // ● 错误 num = 30;
        int num2;
        num2 = 40;
        class Inner{
            public void inner(){
                System.out.println(num);
                System.out.println(num2);
            }
        }
    }
}

从Java 8 开始，只要局部变量事实不变，那么final关键字可以省略。
原因：

new 出来的对象在堆内存当中
局部变量是跟着方法走的，在栈内存当中。
方法运行结束之后，立刻出栈，局部变量就会立刻消失
但是new出来的对象会在堆当中持续存在，直到垃圾回收消失
所以定义为final直接保存一次，不担心消失，也因此不可更改

复习：1. final修饰局部变量： ①创建时直接赋值，②创建时不赋值，后只赋值一次。不可二次赋值，值一样也不行
5. final修饰成员变量① 创建时直接赋值，②在所有重载构造器中赋值。不可写该成员变量的Setter

★ 匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，这种情况可以省略该类的定义，而改为使用【匿名内部类】
匿名内部类的定义格式：

接口名称 对象名 = new 接口名称(){
	//覆盖重写所有抽象方法
};

对格式“new 接口名称（）{……}”进行解析：

new 代表创建对象的动作
接口名称就是匿名内部类需要实现哪个接口
{……}这才是匿名内部类的内容
例：

 public static void main(String[] args) {
        /*实现类实现接口方法并调用*/
        MyInterfaceImpl obj1 = new MyInterfaceImpl();
        obj1.method();
        /*匿名内部类重写接口的抽象方法  */
        MyInterface obj2 = new MyInterface(){
            @Override
            public void method() {
                System.out.println("匿名内部类实现method方法");
            }
        };
        obj2.method();

        //------------------------------------匿名内部类重写接口所有抽象方法
        MyInterface2 obj3 = new MyInterface2(){
            @Override
            public void method1() {
                System.out.println("obj3 匿名内部类实现method1方法");
            }
            @Override
            public void method2() {
                System.out.println("obj3 匿名内部类实现method2方法");
            }
        };
        //注意匿名内部类是有对象名的，可以多次调用方法
        obj3.method1();
        obj3.method2();
        obj3.method2();
        
        //想再使用这个匿名内部类，再new一次相同的对象。只能再写一次内容相同的匿名内部类
        MyInterface2 obj4 = new MyInterface2(){
            @Override
            public void method1() {
                System.out.println("obj4 匿名内部类实现method1方法");
            }
            @Override
            public void method2() {
                System.out.println("obj4 匿名内部类实现method2方法");
            }
        };
        obj4.method1();
        obj4.method2();

实现类实现method方法
匿名内部类实现method方法
匿名内部类实现method1方法
匿名内部类实现method2方法

匿名内部类的注意事项

注意：使用匿名内部类，省略的是实现类（子类）的名称，而不是对象名

匿名内部类，在创建对象时，只能使用唯一一次。（即这个类对象只能new一次，要再new一次，就再写一次包括要重写的方法体）
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类。
匿名对象，在调用方法的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
匿名内部类是省略了实现类/子类名称，但是匿名对象是省略了对象名称
强调：匿名内部类和匿名对象完全不同，也没关系

在这里插入图片描述

如果创建一个匿名内部类的匿名对象呢？
因为匿名对象没有对象名，所以只能创建时调用一次方法

	public static void main(String[] args) {
		//匿名内部类的匿名对象
       //匿名内部类的匿名对象
        new MyInterface2(){
            @Override
            public void method1() {
                System.out.println("匿名对象 的匿名内部类实现 method1 方法");
            }
            @Override
            public void method2() {
                System.out.println("匿名对象 的匿名内部类实现 method2 方法");
            }
        }.method1();
        //匿名对象只能调用一次方法，要调用method2就再创建一次匿名对象
        new MyInterface2(){
            @Override
            public void method1() {
                System.out.println("匿名对象 的匿名内部类实现 method1 方法");
            }
            @Override
            public void method2() {
                System.out.println("匿名对象 的匿名内部类实现 method2 方法");
            }
        }.method2();
   }

● 练习

1. 创建一个成员内部类，在其他类中用直接和间接两种方式，访问该内部类及方法。

A：---------------------------------------------------------------------------------------------------------

public class Body {//外部类
    public class Heart{//成员内部类
        int num = 20;
        //内部类的方法
        public void beat(){
            int num = 30;
            System.out.println("心脏跳动，砰砰");
            System.out.println("我叫：" + name);
        }
    }

    //外部类的成员变量
    private String name;
    int num = 10;
	
    public Body(String name, int num) {
        this.name = name;
        this.num = num;
    }
    public Body(){

    }

    public void methodBody(){
        System.out.println("外部类Body的方法");
    }
    //调用内部类的外部方法
    public void methodHeart(){
        System.out.println("Body类调用内部类Heart及方法");
        Heart heart = new Heart();
        heart.beat();
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
}

package demo01;
public class MainTest {
    public static void main(String[] args) {
        /*1. 创建一个成员内部类，在其他类中用直接和间接两种方式，访问该内部类及方法。*/
        // ● 直接使用
        Body.Heart obj = new Body().new Heart();
		obj.beat();

        Body.Heart obj1 = new Body("barbie", 18).new Heart();
        obj1.beat();
        System.out.println(obj1.num);//20,是内部类的成员变量,因为obj1是内部类

		
        //[奇思]直接使用，new 外部类()相当于一个匿名对象，直接用外部类对象好像也可以
        Body body1 = new Body();
        Body.Heart obj2 = body1.new Heart();
        obj2.beat();
        System.out.println(obj1.num);

        // ● 间接使用,需要外部类有一个调用了内部类的方法
        body1.methodHeart();
    }
}

心脏跳动，砰砰
我叫：null
心脏跳动，砰砰
我叫：barbie
20
心脏跳动，砰砰
我叫：null
20
Body类调用内部类Heart及方法
心脏跳动，砰砰
我叫：null

2. 在【成员内部类】中，在内部类方法和外部类方法中访问同名的，局部变量，内部类成员变量，外部类成员变量。对比【局部内部类】访问同名变量的情况。

A：---------------------------------------------------------------------------------------------------------

成员内部类的情况，三种重名访问

public class Body {//外部类
    public class Heart{//成员内部类
        int num = 20;
        //内部类的方法
        /*1. 成员内部类，在内部类方法和外部类方法中访问同名变量*/
        public void visit(){
            int num = 40;
            System.out.println(num);//40
            System.out.println(this.num);//20
            System.out.println(Body.this.num);//10
        }
    }

    //外部类的成员变量
    private String name;
    int num = 10;

	/*2. 成员内部类，在外部类方法和外部类方法中访问同名变量*/
    public void visit(){
        int num = 50;
        System.out.println(num);//50
        System.out.println(this.num);//10
        System.out.println(new Heart().num);//20
    }
    public Body(String name, int num) {
        this.name = name;
        this.num = num;
    }
    public Body(){

    }
}

	public static void main(String[] args) {
 		Body body1 = new Body();
        Body.Heart obj2 = body1.new Heart();
        body1.visit();
        obj2.visit();
    }

局部内部类访问同名情况

public class Outer {

    int num = 100;
    //局部内部类
    void outClass(){
        System.out.println("-----------------------");

        class Inner{
            int num = 200;
            void inMethod(){
                System.out.println("Inner的method执行");
            }
            /*1.局部内部类方法，访问同名变量*/
            void visit(){
                int num = 300;
                System.out.println("局部内部类visit方法，分别访问重名局部变量，内部类变量和外部类变量");
                System.out.println(num);
                System.out.println(this.num);
                System.out.println(Outer.this.num);
            }
        }

        //局部内部类只能在局部方法里使用
        System.out.println("Outer方法，存在局部内部类并使用");
        Inner inner = new Inner();
        inner.inMethod();
        inner.visit();
        System.out.println("在该外部类方法中访问：局部内部类Inner的成员变量 " + inner.num + ",外部类的成员变量 " + this.num);
        System.out.println("-----------------------");
    }

	/*2.外部类方法，访问同名变量*/
    void visit(){
        int num = 400;
        System.out.println("外部类Ourer的visit方法，分别访问重名局部变量，外部类变量和内部类变量");
        System.out.println(num);
        System.out.println(this.num);
        System.out.println("外部类无法直接访问局部内部类的成员变量，只能调用局部类所在的方法，方法内访问");
    }
}

	public static void main(String[] args) {
		Outer outer1 = new Outer();
        outer1.outClass();
        outer1.visit();
    }

-----------------------
Outer方法，存在局部内部类并使用
Inner的method执行
局部内部类visit方法，分别访问重名局部变量，内部类变量和外部类变量
300
200
100
在该外部类方法中访问：局部内部类Inner的成员变量 200,外部类的成员变量 100
-----------------------
外部类Ourer的visit方法，分别访问重名局部变量，外部类变量和内部类变量
400
100
外部类无法直接访问局部内部类的成员变量，只能调用局部类所在的方法，方法内访问

---------------------------------------------------写法2---------------------------------------------------

package code01;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;
import org.w3c.dom.ls.LSOutput;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: 雪雪子
 * @Date: 2024/04/09/9:50
 * @Description:
 */
public class Outer {
    int num = 10;
    void method(){
        System.out.println("外部类方法");
    }
    void useInner(){
        System.out.println("间接访问内部类极其成员");
        Inner inner = new Inner();
        System.out.println(inner.num);
        inner.method();
    }
    void visit(){
        System.out.println("外部类visit----------------");
        int num = 30;
        System.out.println(num);//30
        System.out.println(this.num);//10
        System.out.println(new Inner().num);//20
    }
    void localInner(){
        class Inner{
            int num = 50;
            void method(){
                System.out.println("局部内部类");
            }
            void visit(){//只能在localInner方法中访问这个方法
                System.out.println("局部内部类的visit----------------");
                int num = 60;
                System.out.println(num);//60
                System.out.println(this.num);//50
                System.out.println(Outer.this.num);//10
            }
        }
        System.out.println("含有局部内部类的方法的visit-------------");
        Inner inner = new Inner();//就近原则，此处访问的是自己方法中的局部内部类。
        // 如果没有这个重名的局部内部类，也不会报错会访问成员内部类
        int num = 70;//如果没有这句，下一句也不会报错，会访问外部类的成员变量num
        System.out.println(num);//? 输出的是哪个num,70
        System.out.println(inner.num);//50
        System.out.println(Outer.this.num);//10
        /*判断这里的this,因为是外部类方法，不在局部内当中，所以this指的还是外部类对象*/
        System.out.println(this.num);//10
        inner.method();
        inner.visit();

    }
    public class Inner{
        int num = 20;
        void method(){
            System.out.println("内部类方法");
        }
        void visit(){
            System.out.println("成员内部类visit-----------");
            int num = 40;
            System.out.println(num);//40
            System.out.println(this.num);//20
            System.out.println(Outer.this.num);//10
        }
    }
}

package code01;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: 雪雪子
 * @Date: 2024/04/09/9:48
 * @Description:
 */
public class MainTest {
    public static void main(String[] args) {
        // 1.创建一个成员内部类，在其他类中用直接和间接两种方式，访问该内部类及方法。
//        Outer.Inner obj1 = new Outer().new Inner();
//        obj1.method();
//        new Outer().useInner();
        // 2. 在【成员内部类】中，在内部类方法和外部类方法中访问同名的，局部变量，
        // 内部类成员变量，外部类成员变量。对比【局部内部类】访问同名变量的情况。
        Outer out = new Outer();
        out.visit();
        Outer.Inner obj2= new Outer().new Inner();
        obj2.visit();

        out.localInner();

        //3. 成员内部类：在外部类访问成员内部类成员，在内部类访问外部类成员。
    }
}

总结：

对于成员内部类
1）内部类方法访问
通过this.成员名访问自己内部类的成员
通过所在外部类名.this.成员名访问外部类成员
直接变量名访问方法内局部变量
2）外部类方法访问
通过this.成员名访问自己外部类的成员
通过所在new 内部类对象()，用内部对象名.成员访问内部类成员
直接变量名访问方法内局部变量
对于局部内部类
1）局部内部类所在的方法访问
注意！通过 this.成员名 访问的是外部类成员，因为局部内部类存在的是外部类方法
通过new当前方法中的内部类，new 内部类对象()，用内部对象名.成员访问内部类成员
直接变量名访问方法内局部变量
2）外部类方法访问
通过this.成员名访问自己外部类成员
无法直接访问内部类成员，只能通过局部内部类所在的方法，访问该外部类方法。（需要该外部类方法中，new了内部类对象并访问方法）
直接变量名访问方法内局部变量

3. 成员内部类：在外部类访问成员内部类成员，在内部类访问外部类成员。

A：---------------------------------------------------------------------------------------------------------

package code03;
	public class Outer {
    int num = 200;

    // ● 外部方法访问内部成员
    void visit(){
        num = 300;
        System.out.println("外部类方法访问");
        Inner inner = new Inner();
        System.out.println(inner.num);
        inner.method();
    }
    void method(){
        System.out.println("外部类方法");
    }
    class Inner{
        String str;
        int num = 100;
        Inner(){
            ;
        }
        Inner(String str, int num){
            this.str = str;
            this.num = num;
        }
        void method(){
            System.out.println("成员内部类方法");
        }
        // ● 内部方法访问外部类成员
        void visit(){
            System.out.println("内部类方法访问");
            System.out.println(Outer.this.num);
            method();//就近原则，优先调用成员内部类方法
            Outer.this.method();
        }
    }
}

package code03;
public class DemoMain {
    public static void main(String[] args) {
        /*3. 在外部类访问成员内部类成员，在内部类访问外部类成员。*/
        Outer out = new Outer();
        out.visit();
        Outer.Inner inner = new Outer().new Inner();
        inner.visit();
    }
}

外部类方法访问
100
成员内部类方法
内部类方法访问
200
成员内部类方法
外部类方法

4. 分析外部类，成员内部类，局部内部类的权限修饰符可能性。

A：---------------------------------------------------------------------------------------------------------
外部类：public ，(default)
局部变量+局部内部类：啥权限修饰符都不行
类中的成员变量和方法＋内部类：public，protected，(default），private

5. 判断，局部内部类访问局部变量对错

public class MyOuter{
	protected void methodOuter(){
		int num1 = 10;
		num1 = 20;
		double num2;
		num2 = 30;
		final int num3;
		num3 = 40;
		final int num4 = 50;
			
		class MyInner{
			public void methodInner(){
				System.out.println(num1);
				System.out.println(num2);
				System.out.println(num3);
				System.out.println(num4);	
			}			
		}
	}
}

A：---------------------------------------------------------------------------------------------------------
局部内部类访问所在方法的局部变量，注意需要有效final

public class MyOuter{
	protected void methodOuter(){
		int num1 = 10;
		 ● num1 = 10;
		double num2;
		num2 = 30;
		final int num3;
		num3 = 40;
		final int num4 = 50;
			
		class MyInner{
			public void methodInner(){
				 ● System.out.println(num1);
				System.out.println(num2);
				System.out.println(num3);
				System.out.println(num4);	
			}			
		}
	}
}

6. 使用匿名内部类实现接口（两个抽象方法），并多次调用其中方法

A：---------------------------------------------------------------------------------------------------------
注意：

package code02;
public interface MyInterface2 {
    void method1();
    void method2();
}

public static void main(String[] args) {
	MyInterface2 obj4 = new MyInterface2(){
          @Override
          public void method1() {
              System.out.println("obj4 匿名内部类实现method1方法");
          }
          @Override
          public void method2() {
              System.out.println("obj4 匿名内部类实现method2方法");
          }
     };
     obj4.method1();
     obj4.method2();
     obj4.method2();   
     obj4.method1();
}

7. 使用匿名内部类new匿名对象，调用两个方法

A：---------------------------------------------------------------------------------------------------------

//匿名内部类的匿名对象
        new MyInterface2(){
            @Override
            public void method1() {
                System.out.println("匿名对象 的匿名内部类实现 method1 方法");
            }
            @Override
            public void method2() {
                System.out.println("匿名对象 的匿名内部类实现 method2 方法");
            }
        }.method1();
        //匿名对象只能调用一次方法，调用method2就再创建一次匿名对象
        new MyInterface2(){
            @Override
            public void method1() {
                System.out.println("匿名对象 的匿名内部类实现 method1 方法");
            }
            @Override
            public void method2() {
                System.out.println("匿名对象 的匿名内部类实现 method2 方法");
            }
        }.method2();

_esther_

关注

27
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
【JavaSE ⑥】P195 ~ P208 final关键词修饰类，方法，局部变量，成员变量；4种权限修饰符；成员内部类，局部内部类，局部内部类的final问题，匿名内部类；复习匿名对象

【JavaSE】P195 ~ P final关键词修饰类，方法，局部变量，成员变量；4种权限修饰符；成员内部类，局部内部类，局部内部类的final问题，匿名内部类；复习匿名对象
复制链接

扫一扫