Java学习笔记⑩（final关键字、内部类）

最新推荐文章于 2024-08-20 11:59:00 发布

添砖 Java

最新推荐文章于 2024-08-20 11:59:00 发布

阅读量173

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/weixin_45994391/article/details/109125037

版权

Java 专栏收录该内容

36 篇文章 3 订阅

订阅专栏

一、final关键字

final关键字代表最终、不可改变的。
常用的四种方法：

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

不能使用一个final类来作为父类

final关键字用于修饰类：

当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {
//…
}
含义：当前这个类不能有任何的子类。(太监类)
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）

package day11.demo01;

public final class MyClass {
    public void method() {
        System.out.println("方法执行！");
    }
}

final关键字用于修饰成员方法：

当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型方法名称(参数列表)
{
//方法体
}
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

package day11.demo01;

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

final关键字用于修饰局部变量：

package day11.demo01;

public class Demo01Final {
    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);//10
        num1=20;
        System.out.println(num1);//20
        //一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
        //"一次赋值，终生不变"
        final int num2 = 200;
        System.out.println(num2);//200
        //num2 = 250;//错误写法，不能改变！
        //num2 = 200;//错误写法！
        //正确写法!只要保证有唯一一次赋值即可
        final int num3;
        num3 = 30;
        //对于基本类型来说，不可变说的是变量当中的数据不可改变
        //对于引用类型来说，不可变说的是变量当中的地址值不可改变
        Student stu1 = new Student("xxx");
        System.out.println(stu1);
        System.out.println(stu1.getName());//xxx
        stu1 = new Student("yyy");
        System.out.println(stu1);
        System.out.println(stu1.getName());//yyy
        System.out.println("==========");
        final Student stu2 = new Student("zzz");
        //错误写法!final的引用类型变量，其中的地址不可改变
        //stu2 = new Student("vvv");
        System.out.println(stu2.getName());//zzz
        stu2.setName("zzzzzzzzzzz");
        System.out.println(stu2.getName());//zzzzzzzzzzz
    }
}

package day11.demo01;

public class Student {
    private String name;
    public Student() {
    }
    public Student(String name) {
        this.name=name;
    }
    public String getName() {
        return name;
    }

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

运行结果：
在这里插入图片描述
final关键字用于修饰成员变量：

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

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

package day11.demo01;

public class Person {
    private final String name /*= "xxx"*/;
    public Person() {
        name = "zzz";
    }
    public Person(String name) {
        this.name=name;
    }

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

四种权限修饰符：
在这里插入图片描述

注意事项:(default)并不是关键字“default”，而是根本不写。

package day11.demo02;

public class Myclass {
    protected int num = 10;
    public void method() {
        System.out.println(num);
    }
}

package day11.demo02;

public class MyAnother {
    public void anothermethod() {
        System.out.println(new Myclass().num);
    }
}

package day11.demo02;

public class Myson extends Myclass {
    public void methodSon() {
        System.out.println(super.num);
    }
}

内部类的概念与分类：

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

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

成员内部类的定义格式：
修饰符 class 外部类名称 {
修饰符 class 内部类名称 {
//…
}
//…
}
注意:内用外，随意访问，外用内，需要内部对象。
==========================
如何使用成员内部类？有两种方式:

间接方式：在外部类的方法中，使用内部类；然后main只是调用外部类的方法。
直接方式：公式：
类名称对象名 = new 类名称();
【外部类名称.内部类名称对象名 = new 外部类名称().new 内部类名称();】

package day11.demo03;

public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();//外部类对象
        //通过外部类的对象，调用外部类的方法，里面间接在使用内部类的Heart
        body.methodBody();
        System.out.println("==============");
        //按照公式写：
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

package day11.demo03;

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

运行结果：
在这里插入图片描述
内部类的同名变量访问：

如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名

package day11.demo03;

public class Demo02InnerClass {
    public static void main(String[] args) {
        //外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
        Outer.Inner obj = new Outer().new Inner();
        obj.methodInner();
    }
}

package day11.demo03;

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);//外部类的成员变量
        }
    }
}

运行结果：
在这里插入图片描述
局部内部类定义：

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
定义格式：
修饰符 class 外部类名称 {
修饰符返回值类型外部类方法名称(参数列表) {
class 局部内部类名称 {
//…
}
}
}

package day11.demo04;

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

package day11.demo04;

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 > protected > (default) > private
定义一个类的时候，权限修饰符规则：

外部类：public / (default)
成员内部类：public / protected / (default) / private
局部内部类：什么都不能写

局部内部类的final问题：

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final的】
备注：从Java 8+开始，只要局部变量事实不变，那么final关键字可以省略。
原因：

new出来的对象在堆内存当中。
局部变量是跟着方法走的，在栈内存当中。
方法运行结束之后，立刻出栈，局部变量就会立刻消失。
但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

package day11.demo04;

public class MyOuter {
    public void methodOuter() {
        final int num = 10;//所在方法的局部变量
        class MyInner {
            public void methodInner() {
                System.out.println(num);
            }
        }
    }
}

局部内部类的注意事项：

如果接口的实现类（或者定义类的子类）只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。
匿名内部类的定义格式：
接口名称对象名 = new 接口名称() {
//覆盖重写所有抽象方法
};
对格式"new 接口名称() {…}"进行解析：

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

另外还需注意的问题：

匿名内部类。在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
匿名对象。在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起一个名字。
匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！

package day11.demo05;

public class DemoMain {
    public static void main(String[] args) {
      //  MyInterface obj = new MyInterfaceImp1();
      //  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");
            }
        };
        objA.method1();
        objA.method2();
        System.out.println("================");
        
        //使用了匿名内部类，而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111-B");
            }

            @Override
            public void method2() {
                System.out.println("匿名内部类实现了方法！222-B");
            }
        }.method2();
    }
}

package day11.demo05;

public class MyInterfaceImp1 implements MyInterface {
    @Override
    public void method1() {
        System.out.println("实现类覆盖重写了方法！111");
    }

    @Override
    public void method2() {
        System.out.println("实现类覆盖重写了方法！222");
    }
}

package day11.demo05;

public interface MyInterface {
    void method1();//抽象方法
    void method2();
}

运行结果：
在这里插入图片描述
类作为成员变量类型：

package day11.demo06;

public class DemoMain {
    public static void main(String[] args) {
        //创建一个英雄角色
        Hero hero = new Hero();
        //为英雄起一个名字，并且设置年龄
        hero.setName("盖伦");
        hero.setAge(20);
        
        //创建一个武器对象
        Weapon weapon = new Weapon("多兰剑");
        //为英雄配备武器
        hero.setWeapon(weapon);
        hero.attack();
    }
}

package day11.demo06;
//游戏当中的英雄角色类
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;
    }
}

package day11.demo06;

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

运行结果：
在这里插入图片描述
接口作为成员变量类型：

package day11.Demo07;

public class DemoGame {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("艾希");//设置英雄的名称

//        //设置英雄的技能
//        hero.setSkill(new SkillImp1());//使用单独定义的实现类
//        //还可以改成使用匿名内部类
//        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();
    }
}

package day11.Demo07;

public interface Skill {
    void use(); //释放技能类型
}

package day11.Demo07;

public class SkillImp1 implements Skill {
    @Override
    public void use() {
        System.out.println("Biu~biu~biu~");
    }
}

package day11.Demo07;

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

接口作为方法的参数和或返回值：

package day11.Demo07;

import java.util.ArrayList;
import java.util.List;

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

运行结果：
在这里插入图片描述

添砖 Java

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
3
评论
Java学习笔记⑩（final关键字、内部类）

一、final关键字final关键字代表最终、不可改变的。常用的四种方法：可以用来修饰一个类可以用来修饰一个方法还可以用来修饰一个局部变量还可以用来修饰一个成员变量不能使用一个final类来作为父类final关键字用于修饰类：当final关键字用来修饰一个类的时候，格式：public final class 类名称 {//…}含义：当前这个类不能有任何的子类。(太监类)注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子。）pac
复制链接

扫一扫

专栏目录