11 final关键字（修饰类、方法、变量）、权限修饰符（4中）、内部类、内部类中this与super、匿名内部类、引用类型总结

最新推荐文章于 2023-01-30 16:43:17 发布
最新推荐文章于 2023-01-30 16:43:17 发布
阅读量270 收藏 1
点赞数
分类专栏： 01 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Birdmotianlun/article/details/108061274
版权

想了解更多请查看java学习（idea版）

目录

final关键字

final修饰类

final修饰方法

final修饰变量

修饰基本类型的局部变量

修饰引用类型的局部变量

修饰成员变量

权限修饰符

内部类

列：实现心脏在身体中跳动

 列：内部类this，super的用法

 列：方法中的内部类

 匿名内部类

引用类型用法总结

列：显示英雄的武器

列：实现英雄释放技能

final关键字

为了避免子类继承父类，使用final关键字

final ： 不可改变。可以用于修饰类、方法和变量。
  1. 类：被修饰的类，不能被继承。
  2. 方法：被修饰的方法，不能被重写。
  3. 变量：被修饰的变量，不能被重新赋值。

 

final修饰类

final修饰类后，此类不能被继承，不能覆盖重写

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

final修饰方法

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

public abstract class Fu {
    public abstract void method();
    public final  void methodFinal(){
        System.out.println("父类--final修饰的方法");
    }
}
/*
子类继承父类。final修饰的方法不能被覆盖重写
 */
public class Zi extends Fu{
    @Override
    public void method() {
    }
    // 错误写法！不能覆盖重写父类当中final的方法
//    @Override
//    public void methodFinal() {
//        System.out.println("子类覆盖重写父类的方法！");
//    }
}

 

final修饰变量

修饰基本类型的局部变量

一次赋值，不可以在改变

 

    public static void main(String[] args) {
        int num = 10;//局部变量
        num = 20;

        //使用final用来修饰局部变量，这个变量不在改变
        final int num1 = 20;
//        num1=30;//错误写法final不可改变
        final int num3;
        num3 = 30;
    }

修饰引用类型的局部变量

引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的

修改 
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;
    }
}
    public static void main(String[] args) {
        //引用数据类型
        Student s1 = new Student("老赵");
        System.out.println(s1 + "\t" + s1.getName());
        s1 = new Student("老钱");
        System.out.println(s1 + "\t" + s1.getName());

        //final修饰的引用数据类型 地址不变
        final Student s2=new Student("老李");
       /*  错误写法！final的引用类型变量，其中的地址不可改变
        s2=new Student("老孙");*/
        System.out.println(s2+"\t"+s2.getName());
        s2.setName("老周");
        System.out.println(s2+"\t"+s2.getName());
    }

 结果：final修饰引用类型的局部变量后，引用类型的地址不在改变

 

修饰成员变量

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一

 成员变量具有默认值，final修饰成员变量之后必须手动赋值，不会再给默认值了。

 

 

权限修饰符

可用范围publicprotected默认（default）private
同类中
同包中  
不同包的子类  
不同包中的无关类   
   成员变量使用 private ，隐藏细节。
   构造方法使用 public ，方便创建对象。
   成员方法使用 public ，方便调用方法。

 

 

 

 

 

内部类

内部类仍然是一个独立的类，在编译之后会内部类会被编译成独立的.class文件，但是前面冠以外部类的类名

和 $符号 。

列：实现心脏在身体中跳动

public class Body {
    //成员内部类
    public class Heart {
        private String myHeart;

        public void beat() {
            System.out.println(name + "心脏跳动");
        }
    }

    private String name;

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

    public String getName() {
        return name;
    }

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

    public void methodMybody() {
//        Heart heart = new Heart();
//        heart.beat();
        new Heart().beat();
    }

}

 

 

public class BodyTest {
    public static void main(String[] args) {
        Body body = new Body("老赵");
        //1通过外部类的成员方法访问内部类
        body.methodMybody();

        //2通过内部类直接访问内部类
        Body.Heart heart = new Body("老钱").new Heart();

        heart.beat();
    }
}

 

 列：内部类this，super的用法

public class Outer {
     int a=10;
    public  class Inner{
        int a=11;
        public void method(){
            int a=12;
            System.out.println(a+"\t"+this.a+"\t"+Outer.this.a);//12	11	10
        }
    }
}
public class OuterTest {

    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        inner.method();
    }
}

 列：方法中的内部类

public class MyOut {
    public void methodMyOut() {

        class Inner {
            //局部内部类中的局部变量，那么这个局部变量必须是【有效final的】
            int a=10 ;

            public void methodInner() {
                System.out.println("方法执行");
            }
        }
        Inner inner = new Inner();
        inner.methodInner();

    }
}
public class demo01Test {
    public static void main(String[] args) {
        MyOut out=new MyOut();
        out.methodMyOut();

    }
}

 

 匿名内部类

匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。

格式

public interface MyInterface {
    void method1();
    void method2();
}

 

public class MyInterfaceImpl implements  MyInterface{
    @Override
    public void method1() {
        System.out.println("MyInterfaceImpl--method1()执行");
    }

    @Override
    public void method2() {
        System.out.println("MyInterfaceImpl--method2()执行");
    }
}
public class Demo01Test {
    public static void main(String[] args) {
        myMethod1();
        System.out.println("-------------------");
        myMethod2();
    }

    //2匿名对象的匿名内部类
    private static void myMethod2() {
        new MyInterface(){
            @Override
            public void method1() {
                System.out.println("匿名对象的匿名内部类--method1");
            }

            @Override
            public void method2() {

            }
        }.method1();

        new MyInterface(){
            @Override
            public void method1() {
                System.out.println("匿名对象的匿名内部类--method1");
            }

            @Override
            public void method2() {
                System.out.println("匿名对象的匿名内部类--method2");

            }
        }.method2();

    }
  //1匿名内部类
    private static void myMethod1() {
        
    MyInterface a=new MyInterface() {
        @Override
        public void method1() {
            System.out.println("匿名内部类--method1()");
        }

        @Override
        public void method2() {
            System.out.println("匿名内部类--method2()");
        }
    };
    a.method1();
    a.method2();

    }

}

 

引用类型用法总结

基本类型可以作为成员变量、作为方法的参数、作为方法的返回值，那么当然引用类型也是可以的。

列：显示英雄的武器

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

    @Override
    public String toString() {
        return "Hero{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", weapon=" + weapon.getCode() +
                '}';
    }
}
public class DemoTest {
    public static void main(String[] args) {
        Hero hero = new Hero("老赵", 19, new Weapon("杀猪刀"));
        System.out.println(hero.toString());
        Hero hero1 = new Hero("老钱", 20, new Weapon("伤人剑"));
        System.out.println(hero1.toString());
    }
}

列：实现英雄释放技能

//英雄技能
public interface HeroSkill {
    void useSkill();
}

public class Hero {
    private String name; // 英雄的名称
    private HeroSkill heroSkill; // 英雄的技能的接口类
    public void myMethod(){
        System.out.println(name+"释放技能：");
        heroSkill.useSkill();
    }

    public Hero() {
    }

    public Hero(String name, HeroSkill heroSkill) {
        this.name = name;
        this.heroSkill = heroSkill;
    }

    public String getName() {
        return name;
    }

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

    public HeroSkill getHeroSkill() {
        return heroSkill;
    }

    public void setHeroSkill(HeroSkill heroSkill) {
        this.heroSkill = heroSkill;
    }

}

接口实现类，实现蛮王英雄技能 

public class HeroSkillImpl implements HeroSkill{


    @Override
    public void useSkill() {
        System.out.println("使用技能--急速快跑");
        System.out.println("使用技能--不死5秒");
    }
}

测试：

public class DemoGame {
    public static void main(String[] args) {
        testMethod01();
        System.out.println("--------------");
        testMethod02();
        System.out.println("--------------");
        testMethod03();

    }
    //3使用实现类实现
    private static void testMethod03() {
        HeroSkill a=new HeroSkillImpl();
        Hero hero=new Hero("蛮王",a);
        hero.myMethod();
    }

    //使用匿名对象的匿名内部类
    private static void testMethod02() {
        Hero hero = new Hero("寒冰", new HeroSkill() {
            @Override
            public void useSkill() {
                System.out.println("使用技能--射箭");
                System.out.println("使用技能--万箭齐发");
            }
        });
        hero.myMethod();
    }

    //1使用匿名内部类
    private static void testMethod01() {
        Hero hero = new Hero();
        hero.setName("德玛--");
        //hero.setHeroSkill(a);写在内部类下边
        HeroSkill a = new HeroSkill() {
            @Override
            public void useSkill() {
                System.out.println("使用技能--旋转刀");
                System.out.println("使用技能--一刀两半");
            }
        };

        hero.setHeroSkill(a);
        hero.myMethod();

    }
}

结果：

 

 

 

 

 

 

 

 

 

 

 

 

 

 

birdlun
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day11 05 final关键字用于修饰成员变量
08-31
day11_05_final关键字用于修饰成员变量
学习笔记（五）：super和this在子类，内部类，实现类，子接口中的使用区别
qq_36988636的博客
07-20 921
一、super和this在子类中的使用 当一个子类继承一个父类时，我们在子类的构造器中通过super()来调用其父类的构造器。 public class FatherClass { FatherClass(){ } } class SonClass extends FatherClass{ SonClass(){ super(); } } 以上是一个最简单的super()的用法，其中如果我们在子类的构造器中省略super()，那么编译器会自动为子类的构造器
面试绞肉机（一）
perfect_yu的博客
01-30 531
面试绞肉机（一）
java 多态 与 重写_类与接口（五）java多态、方法重写、隐藏
weixin_42629522的博客
02-12 101
一、Java多态性面向对象的三大特性：封装、继承、多态。多态的类型，分为以下两种：编译时多态： 指的是 方法重载。编译时多态是在编译时确定调用处选择那个重载方法，所以也叫 静态多态，算不上真正的多态。所以，一般说的多态都是运行时的多态。运行时多态： 由于 方法重写，所以想要确定引用变量所调用的方法的入口，必须根据运行时的引用变量所指向的实例对象来确定。从而使得同一个引用变量调用同一个方法，但不同的...
Java 笔记分享 —— final 关键字
学生
04-20 215
目录 1.1 前言 1.2 最终变量 1.3 最终类 1.4最终方法 1.5最终参数 1.6总结 1.1 前言 final 即为最终关键字，被它修饰即不能再更改。final 可以修饰变量，类，方法甚至是参数，但是不能修饰构造函数。 1.2 最终变量 最终变量一旦被赋值就不能再更改。初始化方法有以下几种： 直接用等号初始化； public class test { ...
java面试题选择题题库
xiaowei1999的博客
06-20 7704
编译运行以下程序后，关于输出结果的说明正确的是 （ ）： public class Conditional{ public static void main(String args[ ]){ int x=4; System.out.println(“value is “+ ((x>4) ? 99.9 :9)); } } 【选项】 A. 输出结果为：value is 99.99 B. 输出结果为：value is 9 C. 输出结果为：value is 9.0 D. 编译错误 【正确答案 ...
面向对象(四)：this关键字，final关键字，抽象类，接口
12-22
通过 this 关键字调用成员方法，解决与局部变量名称冲突问题 package com.wang.demo1; public class Person { int age; //成员变量 age public Person(int age) { //局部变量 age this.age = age; //将局部变量 ...
Java为什么匿名内部类参数引用需要用final进行修饰?
08-26
今天小编就为大家分享一篇关于Java为什么匿名内部类参数引用需要用final进行修饰?，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
Java基础【final、权限、内部类、引用类型】
12-21
day11【final、权限、内部类、引用类型】第一章 final关键字1.1 概述1.2 使用方式修饰类修饰方法修饰变量第二章 权限修饰符2.1 概述2.2 不同权限的访问能力第三章 内部类3.1 概述什么是内部类成员内部类访问特点3.2 ...
java为什么匿名内部类的参数引用时final？final局部变量的生命周期
01-20
在知乎上看到了一篇帖子 在这个问题下面大家已经吵得不可开交了，看了很多篇文章，被误导进了很多的坑，发现只有下面两篇文章是写的最好的，解释的很清楚，我把两篇文章简单的总结了一下： ...1.问题的引出 ...
ClassFinal 字节码加密工具 v1.2.1
09-28
为您提供ClassFinal 字节码加密工具下载，ClassFinal是一款Java class文件安全加密工具，支持直接加密jar包或war包，无需修改任何项目代码，兼容spring-framework，可避免源码泄漏或字节码被反编译。项目模块说明：classfinal-core：ClassFinalde的核心模块，几乎所有加密的代码都在这里；classfinal-fatjar：ClassFinal打包成独立运行的jar包；classfinal
[Java基础] final关键字
不忘初心 方得始终
12-31 726
1、public static final String STRING = "Hello World!"; 修饰类成员变量，该变量在此处赋值后，不允许后面再对该值进行修改，这也就是通常所说的常量。声明常量时必须初始化！ 2、public final String str = "Hello World"; 修饰对象成员变量，赋值后不可更改。与修饰类成员变量不同的是，声明时不一定非要初始化，详见
JAVA——关键final的功能及使用
m0_64251363的博客
03-30 641
一、当final来修饰数据 （一）数据类型是基本数据类型时，则该数据为常量，不能被修改。 （二）是成员变量时，必须当场赋值，否则会出现编译错误。 （三）是引用类型时，比如数组、对象，只能修改它本身而不能修改要引用它的地址。 public class Final用来修饰一个引用 { final int age = 18; String name="zs"; // final String name; final如果修饰的是类的成员变量时，必须当场赋值，否则编译错误
final method java_Java Final关键字示例
weixin_42127369的博客
02-17 540
1. FINAL关键字作为变量修饰符每个上下文都有其自己的不同目的。final，当与变量一起使用时，专门用于限制用户在代码中的其他任何地方更改值。final变量一旦初始化，其值就无法更改。如果final变量只是声明但未初始化，则允许在整个代码中为final变量分配一个值。final变量值的任何多次更改将导致编译错误。例如，如果尝试编译，下面的代码将给出编译时错误。FinalVariable...
static静态初始化块
最近失眠的陶先生
03-09 489
**static可以初始化块对数据进行赋值** 在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。 需要特别注意：**静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。** public class HelloWorld { String name;
细说final的的四种用法-----修饰类，修饰方法，常量，修饰参数 及内部类与final
liuerchong的博客
12-04 6712
final关键字用于修饰类 public final class 类名称 { … } 一个类如果是final的，那么其中所有的成员方法都无法进行覆盖重写,java中典型的final修饰的类 String类 作用：使当前这个类不能有任何子类 说明：当用final修饰一个类时，表明这个类不能被继承。 final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。 在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安
匿名内部类中this的使用问题
毛先森的专栏
07-31 5488
大多数情况下，我在对Android的事件处理方式都是用的基于监听的事件处理方式。在这当中，一般都会涉及到事件监听器这样一个类。大部分的时候，事件监听器都没有什么复用价值，因此大部分的事件监听器只是临时使用一次，所以使用匿名内部类形式的事件监听器更合适。实际上，这种形式也是目前使用最广泛的事件监听器形式。一般用于创建匿名内部类形式的事件监听器都是像这样的：“new 监听器接口”或“new 事件适配器”
关于 static final method 的疑惑
weixin_34049948的博客
06-08 223
前言 在声明一个方法为 static final 时，IDEA 给出了一个 warning： When a static method is overriden in a subclass it can still be accessed via the superclass making the final declaration no...
java中匿名内部类的两种实现方式
iteye_12555的博客
07-25 936
   使用匿名内部类课使代码更加简洁、紧凑，模块化程度更高。内部类能够访问外部内的一切成员变量和方法，包括私有的，而实现接口或继承类做不到。然而这个不是我说的重点，我说的很简单，就是匿名内部类的两种实现方式：第一种，继承一个类，重写其方法；第二种，实现一个接口（可以是多个），实现其方法。下面通过代码来说明：   public class TestAnonymousInterClass{ publ...
Java中被final关键字修饰的变量，不能被重新赋值。
最新发布
06-08
是的，Java中被`final`关键字修饰的变量被称为常量，一旦被赋值后，就不能被重新赋值。如果试图对`final`变量再次赋值，编译器会报错。被`final`修饰的变量可以是成员变量、局部变量或者静态变量。 需要注意的是，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值