final、权限、内部类

最新推荐文章于 2022-02-24 00:26:45 发布
最新推荐文章于 2022-02-24 00:26:45 发布
阅读量258 收藏
点赞数 1
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41675900/article/details/104307038
版权

final
final关键字概念与四种用法

package cn.itcast.day11.demo01;

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

常见四种方法：
1.可以用来修饰一个类
2.可以用来修饰一个方法
3.还可以用来修饰一个局部变量
4.还可以用来修饰一个成员变量
 */
public class Demo01Final {

}

final关键字用于修饰类

package cn.itcast.day11.demo01;
/*
当final关键字用来修饰一个类的时候，格式：
public final class 类名称 {
   //...
}

含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写（因为没儿子）
 */
public final class MyClass {
    public void method(){
        System.out.println("方法执行");
    }
}

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

package cn.itcast.day11.demo01;
/*
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写。
格式：
修饰符 final 返回值类型 方法名称（参数列表）{
    //方法体
}

注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。
 */
public class Fu {
    public final void method(){
        System.out.println("父类方法执行！");
    }
}

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

public class Demo01Final {

    public static void main(String[] args) {
        //一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
        //“一次赋值，终身不变”
        final int num2 = 200;
        System.out.println(num2);

//        num2=250;//错误写法！不能改变！
//        num2=200;//错误写法！

        //正确写法！只要保证有唯一一次赋值即可
        final int num3;
        num3=30;

        //对于基本类型来说，不可变说的是变量当中的数据不可改变
        //对于引用类型来说，不可变说的是变量当中的地址值不可改变。
        Student stu1 = new Student("赵丽颖");
        System.out.println(stu1);
        System.out.println(stu1.getName());//赵丽颖
        stu1=new Student("霍建华");
        System.out.println(stu1);
        System.out.println(stu1.getName());//霍建华
        System.out.println("===========");

        final Student stu2 = new Student("高圆圆");
        //错误写法！final的引用类型变量，其中的地址不可改变
//        stu2 = new Student("赵又廷");
        System.out.println(stu2.getName());//高圆圆
        //地址不可变，但里面的内容可变
        stu2.setName("高圆圆圆圆圆圆");
        System.out.println(stu2.getName());//高圆圆圆圆圆圆
    }
}

final关键字用来修饰成员变量

package cn.itcast.day11.demo01;
/*
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变。

1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一。
3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。
 */
public class Person {
    private final String name /*= "鹿晗"*/;

    public Person() {
        name = "关晓彤";
    }

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

四种权限修饰符

package cn.itcast.day11.demo02;
/*
Java中有四种权限修饰符：
                     public > protected > (default) > private
同一个类 (我自己）       YES      YES          YES        YES
同一个包 （我邻居）       YES      YES          YES        NO
不同包子类 （我儿子）     YES      YES          NO        NO
不同包非子类 （陌生人）   YES       NO          NO        NO

注意事项：（default)并不是关键字“default",而是根本不写。
 */
public class Demo01Main {
}

内部类的概念与分类

package cn.itcast.day11.demo03;
/*
如果一个事物的内部包含另一个事物，那么这就是一个内部包含另一个类。
例如：身体和心脏的关系。又如：汽车和发动机的关系。

分类：
1.成员内部类
2.局部内部类（包含匿名内部类）
 */
public class Demo01InnerClass {
}

成员内部类的定义

package cn.itcast.day11.demo03;
/*
部类的定义格式：
修饰符 class 外部类名称{
       修饰符 class 内部类名称{
        //...
     }
     //...
}
注意：内用外，随意访问；外用内，需要内部类对象。
 */
public class Demo01InnerClass {
}

package cn.itcast.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("外部类的方法");
    }

    public String getName() {
        return name;
    }

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

成员内部类的使用

package cn.itcast.day11.demo03;
/*
如何使用成员内部类？有两种方式：
1.间接方式：在外部类的方法当中，使用内部类；然后main只是调用外部类的方法。
2.直接方式：公式：
类名称 对象名 = new 类名称（）；
【外部类名称.内部类名称 对象名 = new 外部类名称（）.new 内部类名称（）；】
 */
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 cn.itcast.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;
    }
}

内部类的同名变量访问

package cn.itcast.day11.demo03;

//如果出现了重名现象，那么格式是：外部类名称.this.外部类成员变量名
public class Outer {
    int num = 10;//外部类的成员变量

    public class Inner{
        int num = 20;//内部类的成员变量

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

局部内部类定义

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

定义格式：
修饰符 class 外部类名称 {
     修饰符 返回值类型  外部类方法名称（参数列表） {
          class 局部内部类名称 {
           //...
         }
     }
}

小结一下类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符规则：
1.外部类：public/（default)
2.成员内部类： public > protected > (default) > private
3.局部内部类：什么都不能写
 */
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();
    }
}

package cn.itcast.day11.demo04;

public class DemoMain {

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

局部内部类的final问题

package cn.itcast.day11.demo04;
/*
局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是【有效final】的。

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

原因：
1.new出来的对象在堆内存中。
2.局部变量是跟着方法走的，在栈内存当中。
3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
 */
public class MyOuter {
    public void methodOuter(){
        int num = 10;//所在方法的局部变量

        class MyInner{
            public void methodInner(){
                System.out.println(num);
            }
        }
    }

}

匿名内部类
就不用专门写一个接口实现的文件了

package cn.itcast.day11.demo05;
/*
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下就可以省略该类的定义，而改为使用【匿名内部类】。

匿名内部类的定义格式：
接口名称 对象名 = new 接口名称（）{
     //覆盖重写所有抽象方法
}；
 */
public class DemoMain {
    public static void main(String[] args) {
//        MyInterface obj = new MyInterfaceImpl();
//        obj.method();

//        MyInterface some = new Myinterface();//错误写法！

        //使用匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法！");
            }
        };
        obj.method();
    }
}

package cn.itcast.day11.demo05;

public interface MyInterface {

    void method();//抽象方法
}

匿名内部类的注意事项

package cn.itcast.day11.demo05;
/*
new 接口名称（）{...}”进行解析：
1.new代表创建对象的动作
2.接口名称就是匿名内部类需要实现哪个接口
3.{...}这才是匿名内部类的内容

另外还要注意几点问题：
1.匿名内部类，在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就必须使用单独定义的实现类了。
2.匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
3.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！
 */
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("匿名内部类实现了方法！111A");
            }

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

        //使用了匿名内部类，而且省略了对象名称，也是匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111B");
            }

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

        //因为匿名对象无法调用第二次方法，所以需要再创建一个匿名内部类的匿名对象
        new MyInterface() {
            @Override
            public void method1() {
                System.out.println("匿名内部类实现了方法！111B");
            }

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

    }
}

类作为成员变量类型

package cn.itcast.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 cn.itcast.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 cn.itcast.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 cn.itcast.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 cn.itcast.day11.demo07;

public interface Skill {

    public void use();
}

package cn.itcast.day11.demo07;

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

package cn.itcast.day11.demo07;

import java.sql.SQLOutput;

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

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

package cn.itcast.day11.demo07;

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

/*
java.util.list正是ArrayList所实现的接口。
 */
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;
    }
}

发红包案例

weixin_41675900
关注
专栏目录
Java基础权限控制与final，内部类
03-31
Java是一种广泛使用的面向对象的编程语言，它提供了丰富的功能来帮助开发者构建各种应用程序...在实际开发中，合理地使用final和权限控制可以提高代码的安全性，而内部类的恰当应用则可以提升代码的表达力和组织结构。
Java基础知识笔记5
Kuber
09-21 239
final关键字 概述 final关键字代表最终、不可改变的。 常见四种用法 1.用来修饰一个类。 2.用来修饰一个方法。 3.用来修饰一个局部变量。 4.用来修饰一个成员变量。 用来修饰一个类 格式： public final class 类名称{ //内容 } 含义：当前这个类不能有任何的子类。（太监类） 注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。（因为没儿子） 用来修饰一个方法 当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重
Java反射
m0_49508485的博客
02-24 497
1. 什么是反射？ 反射就是Reflection，Java的反射是指程序在运行期可以拿到一个对象的所有信息。 在不使用反射的情况下，通常我们要想调用一个类的方法，或者访问一个类的字段，我们需要传入一个对象实例： // Main.java import com.itranswarp.learnjava.Person; public class Main { String getFullName(Person p) { return p.getFirstName() + " "
Java面向对象第六章：final、权限、内部类、引用类型
Chosen One
09-01 537
一、final关键字 1.1 final关键字的作用 继承中有提到子类可以继承父类的成员方法和public变量，如果我们不希望子类继承并随意改写父类的某些内容，我们就可以使用Java提供的final关键字，用于修饰不可变的内容。 final：不可改变，可修饰类，方法，变量 修饰类时：被修饰的类不可被继承 修饰方法时：被修饰的方法不能被重写 修饰变量时：被修饰的变量，不能被重新赋值 1.2 final关键字的使用格式 1.2.1 修饰类 查询API时一些类比如...
final类的使用格式及使用注意事项
nengsong111的博客
09-02 1081
当final关键字用来修饰一个类的时候，格式： public final class 类名称{ … } 含义：当前这个类不能有任何子类 （太监类） 注意：一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写。 对于类、方法来说，abstract关键字和final不能同时使用 常用四种方法： 1.可以用来修饰一个类 2.可以用来修饰一个方法 3.可以用来修饰一个局部变量 4.可以用来修饰一个成员变量 对于成员变量： 1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了
Java中的final关键字
jl08133341的博客
02-01 237
1.final含义 final意为最终的，不可改变的。 2.final用法 修饰类：格式 public final class 类名{……}，表示当前类不能有子类，一个类如果是final类，那么其中所有的成员方法都无法被覆盖重写。 修饰方法：格式 修饰符 final 返回值类型 方法名称(参数列表){……}，表示给方法为最终方法，即不能被覆盖重写。 修饰局部变量：格式 final 变量类型 变量名，这个变量不能进行修改，一次赋值终生不变。如果是一个基本类型，就是数据不变；如果是一个引用数据类型，就
Java基础【final、权限、内部类、引用类型】
12-21
day11【final、权限、内部类、引用类型】第一章 final关键字1.1 概述1.2 使用方式修饰类修饰方法修饰变量第二章 权限修饰符2.1 概述2.2 不同权限的访问能力第三章 内部类3.1 概述什么是内部类成员内部类访问特点3.2 ...
11.【final、权限、内部类】.zip
01-31
在Java编程语言中，`final`关键字、权限控制和内部类是三个重要的概念，它们各自在不同的场景下发挥着关键作用。接下来，我们将详细探讨这三个主题。 首先，`final`关键字在Java中扮演着不可变性的角色。它可以用于...
day11【final、权限、内部类】.pdf
02-20
通过文件内容的描述，我们可以看出`final`关键字的使用、权限修饰符的定义和作用、内部类的概念及其优势、以及引用类型在Java编程中的重要性和应用场景。这些知识点对于理解Java编程的基本概念和提高编程技能至关...
11【final、权限、内部类】1
08-04
例如，`String`、`Math`和`Scanner`等核心类都是`final`的，以保护其内部实现不被篡改。 2. 修饰方法：`final`修饰的方法不能被子类重写。这有助于保持方法的行为一致性，防止在子类中改变父类原有的功能。如果一个...
【2018-8-19】【day11】
方慕珩
08-19 176
【2018/8/19】   Final关键字代表最终、不可改变的。 常见的四种用法： 可以用来修饰一个类。Public final class 类名称{ // }【当前类不能有任何子类，其中所有的成员方法都不能进行覆盖重写。】 可以用来修饰一个方法。这个方法就是最终方法，不能被覆盖重写。修饰符 final  返回值类型 类名（参数列表）{}【对于类、方法来说，abstract关键字和fin...
final关键字概念及其四种用法、四种权限修饰符的优先级以及内部类的相关概念
派拉斯兔子的博客
11-30 397
final关键字代表最终、不可改变的。 常见的四种用法： ①、可以用来修饰一个类。 ②、可以用来修饰一个方法。 ③、还可以用来修饰一个局部变量。 ④、还可以用来修饰一个成员变量。 （1）、修饰一个类 当final关键字用来修饰一个类的时候，格式如下： public final class 类名称 { //... } 含义：当前这个类不能有任何的子类。 不能使用一个final类来作为父类。 注意：一个如果是final的，那么其中所有的成员方法都无法进行覆盖重写。 （2）、修饰一个方法 当final关键
细说final的的四种用法-----修饰类，修饰方法，常量，修饰参数 及内部类与final
liuerchong的博客
12-04 7231
final关键字用于修饰类 public final class 类名称 { … } 一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写,java中典型的final修饰的类 String类 作用：使当前这个类不能有任何子类 说明：当用final修饰一个类时，表明这个类不能被继承。 final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。 在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安
Class类全面深入学习
woslx的博客
05-21 873
笔记：Class类全面深入学习 本文动机：看各类框架源码时，发现很多反射逻辑看不懂，究其原因是很多Class对象的方法都是第一次见，也不知道其作用。原以为对反射还算比较了解了，看了框架源码才知道，对反射的了解，还局限于对构造函数，方法，Field的使用上。为了方便看源码，决定全面地撸一遍Class的方法的功能。 类声明 Class的声明： public final class Class<T> implements java.io.Serializable,
java之Class类
深海微澜
06-01 3776
Class类也是一个Java类，它也可以实例化得到对象，与普通类不一样的是Class类中存储的是其它类的类型信息。位于java.lang包。 声明： public final class Class<T>implements java.io.Serializable, java.lang.reflect.GenericDeclaration,java.lang.reflect.Type,java.lang.reflect.AnnotatedElement class类有final 修饰.
final class java_Java 中常见的 final 类
weixin_34213766的博客
02-12 1904
Java 中常见的 final 类java.lang 包public final class Booleanextends Objectimplements Serializable, Comparablepublic final class Byteextends Numberimplements Comparablepublic final class Characterextends Obj...
JAVA阻止继承：final类和方法
qq_39429962的博客
10-29 1795
有时候，为了阻止人们利用某个类定义子类。不允许扩展的类被称为final类。可以将类声明为final类，也可以将方法设置为final方法，这样子类就不能覆盖父类的某个方法（将类声明为final类只会将其中的所有的方法声明为final方法）。 public final class A { ... }   public class A { ... public fina...
Java提升学习（四）：final关键字、内部类
weixin_43818177的博客
04-15 195
Java提升学习（四）：final关键字、内部类 一、final关键字 final关键字以为：不可改变的。可用于修饰类、方法和变量。 当被修饰类的时候，类不可被继承。 当被修饰方法的时候，不可被覆盖重写。 当被修饰变量的时候，不可被赋值。 修饰类： public final class 类名 { } 修饰方法： 修饰符 final 返回值类型 方法名(参数列表){ //方法...
Java基础：final、权限、内部类与引用类型详解
在Java基础课程中，"final"关键字是关键的概念之一，它在章节一得到了深入探讨。final是一个静态类型的关键字，具有...后续章节会进一步探讨权限修饰符、内部类和引用类型的用法，这些都是Java编程中不可或缺的部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值