final关键字、权限、内部类
程序员文章站
2022-04-01 10:31:54
一:final关键字、权限、内部类1.final 概述学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字,用于修饰不可改变内容。2.final使用方法final 不可改变的,用来修饰类 、方法、变量类:被修饰的类,不能被继承.方法 : 被修饰的方法,不能被重写.变量:被修饰的变量,不能被重新赋值.使用方法:...
一:final关键字、权限、内部类
1.final 概述
- 学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字,用于修饰不可改变内容。
2.final使用方法
-
final 不可改变的,用来修饰类 、方法、变量
- 类:被修饰的类,不能被继承.
- 方法 : 被修饰的方法,不能被重写.
- 变量:被修饰的变量,不能被重新赋值.
-
使用方法:
-
格式:
final class 类名{} -
我们以前学习过的常用类中,有很多都是给我们直接使用的,不可被外界修改的类,都是被final修饰的.
- public final class String
- public final class Math
- public final class Scanner 等
-
final 修饰方法
-
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
-
格式
格式： 修饰符 final 返回值类型 方法名称(参数列表) { // 方法体 } -
被final修饰的方法不可被重写,重写发生在继承或者接口,就是为了扩展功能,而final定义的是不可变的,因此要切记: final 和abstract 不可同时使用.
-
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
-
-
final修饰变量
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。
- 由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
- 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
- 必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
-
二:权限
四种权限修饰符
Java中有四种权限修饰符：
public > protected > (default) > private
同一个类（我自己） YES YES YES YES
同一个包（我邻居） YES YES YES NO
不同包子类（我儿子） YES YES NO NO
不同包非子类（陌生人） YES NO NO NO注意事项：(default)并不是关键字“default”，而是根本不写。
三:内部类
1.内部类的概念
如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。
2.内部类的分类
- 成员内部类
- 局部内部类[包含匿名内部类]
3.成员内部类
-
成员内部类的定义格式
修饰符 class 外部类名称 { 修饰符 class 内部类名称 { // ... } // ... }注意 :内用外,随便用,外用内,需要内部类对象.
-
如何使用成员内部类？有两种方式：
- 间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
- 直接方式，公式：
类名称 对象名 = new 类名称();
【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】
-
代码写法
public class Body { // 外部类 public class Heart { // 成员内部类 // 内部类的方法 public void beat() { System.out.println("心脏跳动：蹦蹦蹦！"); System.out.println("我叫：" + name); // 正确写法！ } } // 外部类的成员变量 private String name; // 外部类的方法 public void methodBody() { System.out.println("外部类的方法"); new Heart().beat(); } public String getName() { return name; } public void setName(String name) { this.name = name; } } -
测试类
public class Demo01InnerClass { public static void main(String[] args) { //先创建一个外部类对象 Body body = new Body(); /* public void methodBody() { System.out.println("外部类的方法"); new Heart().beat(); }*/ //通过调用外部类的方法来访问内部类的方法 body.methodBody(); System.out.println("======="); //【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】 Body.Heart heart = new Body().new Heart(); heart.beat(); } } -
内部类的成员变量重名问题 :如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
// 如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名 public class Outer { int num = 10; // 外部类的成员变量 public class Inner /*extends Object*/ { 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 Demo02InnerClass { public static void main(String[] args) { // 外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称(); Outer.Inner obj = new Outer().new Inner(); obj.methodInner(); } }
4.局部内部类(包含匿名内部类)
-
概念:
听到这个概念,顾名思义,就是在外部类的方法里定义了内部类.该内部类仅仅属于这个方法,出了这个方法以外的,就访问不到了.
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。定义格式： 修饰符 class 外部类名称 { 修饰符 返回值类型 外部类方法名称(参数列表) { class 局部内部类名称 { // ... } } } -
代码演示
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(); } } -
小小总结:
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】。
备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
原因：
- new出来的对象在堆内存当中。
- 局部变量是跟着方法走的，在栈内存当中。
- 方法运行结束之后，立刻出栈，局部变量就会立刻消失。
- 但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
5.匿名内部类[用的最多]
-
先举个例子[正常的接口使用步骤]
-
定义接口
-
创建接口的实现类,重写接口里的所有抽象方法
-
实现类.方法名调用.
public interface MyInterface { void method1(); // 抽象方法 void method2(); }public class MyInterfaceImpl implements MyInterface { @Override public void method1() { System.out.println("实现类覆盖重写了方法！111"); } @Override public void method2() { System.out.println("实现类覆盖重写了方法！222"); } }//通过多态的写法来调用方法 MyInterface obj = new MyInterfaceImpl(); obj.method();
-
-
使用匿名内部类的做法
-
定义接口,创建抽象方法
-
创建一个测试类,直接在main 方法 通过匿名内部类的指定格式 new 接口 ,调用方法执行
-
匿名内部类的格式: 不要忘记分号
匿名内部类的定义格式： 接口名称 对象名 = new 接口名称() { // 覆盖重写所有抽象方法 }; -
代码展示
public class DemoMain { public static void main(String[] args) { // MyInterface obj = new MyInterfaceImpl(); // obj.method(); // MyInterface some = new MyInterface(); // 错误写法！ // 使用匿名内部类，但不是匿名对象，对象名称就叫objA MyInterface objA = new MyInterface() { @Override public void method1() { System.out.println("匿名内部类实现了方法！111-A"); } @Override public void method2() { System.out.println("匿名内部类实现了方法！222-A"); } }; } }
-
-
使用匿名内部类的注意事项
-
格式解析
对格式“new 接口名称() {…}”进行解析：
- new代表创建对象的动作
- 接口名称就是匿名内部类需要实现哪个接口
- {…}这才是匿名内部类的内容
-
注意问题
- 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。 - 匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。 - 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
- 匿名内部类，在【创建对象】的时候，只能使用唯一一次。
-
强调：匿名内部类和匿名对象不是一回事！！！
- 匿名内部类:省略了接口的是实现类的书写,直接通过特殊的new接口来创建接口的实现类,并用匿名内部类的名字作为对象名,对方法进行调用.
- 匿名对象,判断这个对象仅仅会使用一次,不需要给这个对象一个名字,用完了就找不到了.
-
-
使用匿名对象调用方法
- 使用了匿名内部类，而且省略了对象名称，也是匿名对象
- 因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
- 若要重复使用,则不能用匿名的东西.
new MyInterface() { @Override public void method1() { System.out.println("匿名内部类实现了方法！111-B"); } @Override public void method2() { System.out.println("匿名内部类实现了方法！222-B"); } }.method1();
6.类作为成员变量类型
-
知识回顾
-
定义一个类所需要的那些东西呢?
- 类要成员变量和成员方法
- 成员变量可不可以用一个类作为他的成员变量呢 .答案是肯定的.下面我们来模拟一下.
-
模仿英雄联盟的角色和装备来看,一个英雄,要有名字,要有方法,还要有装备,那么装备也要有名字,装备也要有他自己的功能提供给英雄使用.
-
定义一个武器类
public class Weapon { private String code; // 武器的代号 public Weapon() { } public Weapon(String code) { this.code = code; } public String getCode() { return code; } public void setCode(String code) { this.code = code; } } -
定义英雄类
// 游戏当中的英雄角色类 public class Hero { private String name; // 英雄的名字 private int age; // 英雄的年龄 private Weapon weapon; // 定义一个武器类作为我的一个属性. public Hero() { } public Hero(String name, int age, Weapon weapon) { this.name = name; this.age = age; this.weapon = weapon; } public void attack() { System.out.println("年龄为" + age + "的" + name + "用" + weapon.getCode() + "攻击敌方。"); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public Weapon getWeapon() { return weapon; } public void setWeapon(Weapon weapon) { this.weapon = weapon; } } -
定义一个测试类
public class DemoMain { public static void main(String[] args) { // 创建一个英雄角色 Hero hero = new Hero(); // 为英雄起一个名字，并且设置年龄 hero.setName("盖伦"); hero.setAge(20); // 创建一个武器对象 Weapon weapon = new Weapon("AK-47"); // 为英雄配备武器 hero.setWeapon(weapon); // 年龄为20的盖伦用多兰剑攻击敌方。 hero.attack(); } }
-
-
同理 ,引用类型均可以作为一个类的成员变量.
-
7.接口作为成员变量类型
-
定义一个普通的英雄类,英雄的成员变量需要要给技能的接口.具体的实现看下面的代码.
-
定义一个技能接口.
public interface Skill { void use(); // 释放技能的抽象方法 } -
定义一个技能接口的实现类.
public class SkillImpl implements Skill { @Override public void use() { System.out.println("Biu~biu~biu~"); } } -
定义一个英雄类,成员变量需要一个技能接口
public class Hero { private String name; // 英雄的名称 private Skill skill; // 英雄的技能 public Hero() { } public Hero(String name, Skill skill) { this.name = name; this.skill = skill; } public void attack() { System.out.println("我叫" + name + "，开始施放技能："); skill.use(); // 调用接口中的抽象方法 System.out.println("施放技能完成。"); } public String getName() { return name; } public void setName(String name) { this.name = name; } public Skill getSkill() { return skill; } public void setSkill(Skill skill) { this.skill = skill; } } -
定义一个测试类.
public class DemoGame { public static void main(String[] args) { Hero hero = new Hero(); hero.setName("艾希"); // 设置英雄的名称 // 设置英雄技能 // hero.setSkill(new SkillImpl()); // 使用单独定义的实现类 // 还可以改成使用匿名内部类 // Skill skill = new Skill() { // @Override // public void use() { // System.out.println("Pia~pia~pia~"); // } // }; // hero.setSkill(skill); // 进一步简化，同时使用匿名内部类和匿名对象 hero.setSkill(new Skill() { @Override public void use() { System.out.println("Biu~Pia~Biu~Pia~"); } }); hero.attack(); } }
8.接口作为方法的参数和方法的返回值
-
定义一个方法,传入参数为一个空集合,返回一个装满东西的集合.
public class DemoInterface { public static void main(String[] args) { // 左边是接口名称，右边是实现类名称，这就是多态写法 List<String> list = new ArrayList<>(); List<String> result = addNames(list); for (int i = 0; i < result.size(); i++) { System.out.println(result.get(i)); } } public static List<String> addNames(List<String> list) { list.add("迪丽热巴"); list.add("古力娜扎"); list.add("玛尔扎哈"); list.add("沙扬娜拉"); return list; } }
本文地址：https://blog.csdn.net/TiAmonal/article/details/107892364
推荐阅读
-
JAVA-this关键字JAVAsuper关键字JAVA-static修饰符和final以代码块内部类和枚举
-
Java—final关键字、权限修饰符、内部类
-
final关键字、权限、内部类
-
static介绍、内部类、final、权限修饰符的作用范围
-
达内javaSE_day06 学习笔记 —— 对象的造型、关键字（static，final）
-
达内javaSE_day07 学习笔记 —— 关键字（abstract，interface）、内部类
-
JAVA-this关键字JAVAsuper关键字JAVA-static修饰符和final以代码块内部类和枚举
-
Java—final关键字、权限修饰符、内部类
-
final关键字、权限、内部类