devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：Gausst松鼠会 | 2024-05-15 18:05:52

赞

踩

java final成员变量

目录

final 关键字

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

常见四种用法：

  1. 可以用来修饰一个类
  2. 可以用来修饰一个方法
  3. 还可以用来修饰一个局部变量
  4. 还可以用来修饰一个成员变量

final修饰类

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

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

  • 1
  • 2
  • 3

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

final修饰方法

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

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

  • 1
  • 2
  • 3

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

final修饰局部变量

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

final修饰成员变量

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

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

● 练习

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

a.

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

b.

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


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

c.

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


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

d.

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

f.

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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());//内容正常显示，但并不是同一个对象

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

写法2

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

四种权限修饰符

在这里插入图片描述

● 练习

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

判断点2，同包不同类

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

判断点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);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

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

内部类

内部类的概念与分类

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

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

成员内部类的定义

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

注意： 内用外，随意访问；外用内，需要内部类对象
编译时，在包名或类名上右键选 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;
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  1. 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法
public class MainTest {
    public static void main(String[] args) {
		Body body = new Body();//外部类的对象
		//通过外部类的对象，调用外部类的方法，里面间接在使用内部类Heart
		body.methodBody();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  1. 直接方式：公式：外部类名称.内部类名称 对象名 = 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);
     }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

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

  1. 内部类方法访问重名变量
    如果出现了重名现象，格式：外部类名称.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);//外部类的成员变量
		}
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  1. 外部类方法访问重名变量
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);//内部类的成员变量，在外部类中必须用内部类对象访问
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

局部内部类定义

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

格式：

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

例：

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
public class DemoMain{
	public static void main(String[] args){
		Outer obj = new Outer();
		obj.methodOuter();
	}
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

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

  • 局部内部类类似局部变量，不可以写权限修饰符。与（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);
            }
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

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

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

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

★ 匿名内部类

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

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

  • 1
  • 2
  • 3

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

  1. new 代表创建对象的动作
  2. 接口名称就是匿名内部类需要实现哪个接口
  3. {……}这才是匿名内部类的内容
    例：
 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();

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
实现类实现method方法
匿名内部类实现method方法
匿名内部类实现method1方法
匿名内部类实现method2方法


  • 1
  • 2
  • 3
  • 4
  • 5

匿名内部类的注意事项

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

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

在这里插入图片描述
在这里插入图片描述

  • 如果创建一个匿名内部类的匿名对象呢？
    因为匿名对象没有对象名，所以只能创建时调用一次方法
	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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

● 练习

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
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();
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
心脏跳动，砰砰
我叫：null
心脏跳动，砰砰
我叫：barbie
20
心脏跳动，砰砰
我叫：null
20
Body类调用内部类Heart及方法
心脏跳动，砰砰
我叫：null

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

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(){

    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
	public static void main(String[] args) {
 		Body body1 = new Body();
        Body.Heart obj2 = body1.new Heart();
        body1.visit();
        obj2.visit();
    }

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
50
10
20
40
20
10

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 局部内部类访问同名情况
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("外部类无法直接访问局部内部类的成员变量，只能调用局部类所在的方法，方法内访问");
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
	public static void main(String[] args) {
		Outer outer1 = new Outer();
        outer1.outClass();
        outer1.visit();
    }

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

---------------------------------------------------写法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
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

总结：

  1. 对于成员内部类
    1）内部类方法访问
    通过this.成员名访问自己内部类的成员
    通过所在外部类名.this.成员名访问外部类成员
    直接变量名访问 方法内局部变量
    2）外部类方法访问
    通过this.成员名访问自己外部类的成员
    通过所在new 内部类对象()，用内部对象名.成员访问内部类成员
    直接变量名访问 方法内局部变量
  2. 对于局部内部类
    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();
        }
    }
}


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
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();
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
外部类方法访问
100
成员内部类方法
内部类方法访问
200
成员内部类方法
外部类方法


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

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

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

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

  • 1
  • 2
  • 3
  • 4
  • 5
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();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

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

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/574314
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号