java学习day13——final关键字、内部类

最新推荐文章于 2021-04-21 19:03:29 发布
最新推荐文章于 2021-04-21 19:03:29 发布
阅读量164 收藏
点赞数
分类专栏： java入门学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38126296/article/details/105013980
版权

文章目录

final关键字

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

1. 可以用来修饰一个类

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

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

2. 可以用来修饰一个方法

当final关键字用来修饰一个方法时，这个方法就是最终方法，也就是不能覆盖重写
注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

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

3. 可以用来修饰一个局部变量

当final关键字修饰一个局部变量时，该局部变量就永远不能进行更改

public class Demo01Final {
    public static void main(String[] args) {
        final int num1 = 10;//num1不能进行更改
        //正确写法，只要保证唯一一次赋值即可
        final int num2;
        num2 = 20;
        //对于基本类型来说，不可改变变量中的数据不可改变
        //对于引用类型来说，不可改变是变量当中的地址值不可改变
        final Student stu2 = new Student("高圆圆");
        // 错误写法!final的引用类型变量，其中的地址不可改变
//        stu2 = new Student("赵又廷");
        // 正确写法，内容可以改变
        stu2.setName("赵又廷");
    }
}

Java中基本类型和引用类型的区别

4. 可以用来修饰一个成员变量

成员变量用final修饰后也不可变
注意：
a. 由于成员变量有默认值，所以用了final之后必须手动赋值
b. 对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。（二者选其一）
c. 必须保证类当中所有重载的构造方法，都最终会对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;
//    }
}

Java中四种权限修饰符

/*
Java中有四种权限修饰符
                   public  >   protected >   (default)   >   private
同一个类(我自己)      YES           YES           YES            YES
同一个包(我邻居)      YES           YES           YES             NO
不同包子类(我儿子)    YES           YES            NO             NO
不同包非子类(陌生人)  YES            NO            NO             NO
(default)是根本不写
 */

内部类

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

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

成员内部类

Body类

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

main方法

/*
成员内部类的定义格式：
修饰符 class 外部类名称{
    修饰符 class 内部类名称）{
        // ...
    }
    // ...
}
注意：内用外，随意访问；外用内，需要借助内部类对象
=====================
如何使用成员内部类？有两种方法:
1. 间接方式：再外部类的方法中，使用内部类，然后main只是调用外部类的方法
2. 直接方式：公式：
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
 */
public class Demo01InnerClass {
    public static void main(String[] args) {
        Body body = new Body();
        //间接方式：再外部类的方法中，使用内部类，然后main只是调用外部类的方法
        body.methodBody();
        System.out.println("================");
        // 直接方式
        Body.Heart heart = new Body().new Heart();
        heart.beat();
    }
}

内部类的同名变量访问

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

局部内部类

/*
如果一个类是定义在一个方法内部的，那么这就是一个局部内部类
“局部”：只有当前所属的方法才能使用它，出了这个方法就不能用了
定义格式：
修饰符 class 外部类名称{
    修饰符 返回值类型 外部类方法名称（参数列表）{
        class 局部内部类名称{
            // ...
        }
    }
}
定义一个类的时候，权限修饰符规则：
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);
            }
        }
        Inner inner = new Inner();
        inner.methodInner();
    }
}

局部内部类的final问题

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

  1. new出来的对象在堆内存中
  2. 局部变量是跟着方法走的，在栈内存中
  3. 方法运行结束后，立即出栈，局部变量就会立刻消失
  4. 但是new出来的对象会在堆当中持续存在，知道垃圾回收为止

匿名内部类（重点）

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

对格式“new 接口名称(){...}”进行解析
1. new代表创建对象的动作
2. 接口名称就是匿名内部类需要实现哪个接口
3. {...}则才是匿名内部类的内容

另外还需要注意几点问题：
1. 匿名内部类，在创建对象的时候，只能使用唯一一次。
如果希望多次创建对象且类的内容一样，就必须使用单独定义的实现类
2. 匿名对象，在【调用方法】的时候，只能调用唯一一次
如果希望同一个对象，调用多次方法，那么必须给对象七个名字
3. 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事
 */
public class DemoMain {
    public static void main(String[] args) {
        // 使用匿名内部类
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法");
            }
        };
        //既是匿名内部类，也是匿名对象
        obj.method();//匿名内部类实现了方法
        new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类实现了方法");
            }
        }.method();
    }
}

类作为成员变量类型

public class Hero {
    private String name; //英雄姓名
    private int age; //英雄年龄
    // 类做成员变量
    private Weapon weapon; //武器

    public void attack(){
        System.out.println(age+"岁的"+name+"在用"+weapon.code+"攻击敌人");
    }

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

weapon类做hero类的成员变量

public class Weapon {
    public String code;//武器代号

    public Weapon(String code) {
        this.code = code;
    }

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}
public class DemoMain {
    public static void main(String[] args) {
        Hero hero = new Hero();
        Weapon weapon = new Weapon("AK-47");
        hero.setName("亚瑟");
        hero.setAge(20);
        hero.setWeapon(weapon);
        hero.attack();//20岁的亚瑟在用AK-47攻击敌人
    }
}

接口做成员变量

public class Hero {
    private String name; //英雄姓名
    private 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 interface Skill {
    void use();
}

接口实现类

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

main方法

public class DemoMain {
    public static void main(String[] args) {
        Hero hero = new Hero();
        hero.setName("亚瑟");
        // 设置英雄技能
        hero.setSkill(new SkillImpl());
        hero.attack();

        // 还可以改成使用匿名内部类
        Skill skill = new SkillImpl(){
            @Override
            public void use() {
                System.out.println("pia~biu~pia~biu");
            }
        };
        hero.setSkill(skill);
        hero.attack();

        // 进一步简化，同时使用匿名内部类和匿名对象
        hero.setSkill(new SkillImpl(){
            @Override
            public void use() {
                System.out.println("pia~pia~pia");
            }
        });
        hero.attack();
    }
}

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

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 = addName(list);
        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }
    }
    public static List<String> addName(List<String> list){
        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");
        return list;
    }
}
Echo_Yang7
关注
专栏目录
day11 02 final关键字用于修饰类
08-31
day11_02_final关键字用于修饰类
final、权限、内部类
weixin_41675900的博客
02-16 259
final final关键字概念与四种用法 package cn.itcast.day11.demo01; /* final关键字代表最终、不可改变的。 常见四种方法： 1.可以用来修饰一个类 2.可以用来修饰一个方法 3.还可以用来修饰一个局部变量 4.还可以用来修饰一个成员变量 */ public class Demo01Final { } final关键字用于修饰类 package...
java基础语法练习第四章
DecorateCC的博客
04-21 7183
类的继承 1、已知类的继承关系如下： class A class B extends A class C extends A 则以下语句能通过编译的是（ ） A、A a=new B(); B、C c=new B(); C、C c=new A(); D、B b=new C();
Java学习之关键词final
秋水惊鸿的博客
02-27 228
final关键词主要可以用来变量的声明、final方法以及final类，下面逐个介绍。 final变量 final定义的变量，一旦被设定，就不可以再改变变量的值，同时必须在申明的时对其进行赋值操作（有些情况申明后赋值也可以，但是为培养良好的编程习惯，声明的时候赋值最好）。 final可以修饰一般的常量，同时也可以修饰对象引用，由于数组也可以被看作对象来引用，所以final也可以修饰数组。...
final关键字作用详解
大屎蛋教程网
05-19 2259
final关键字作用详解目录1 final关键字常用应用场景  1.1 单例模式  1.2 静态配置文件解析后的初始化2 final关键字初始化3 在构造函数中参数用final关键字修饰的作用4 final在集合中的应用  4.1 将集合类对象定义为final  4.2 集合类中的对象设置为final5 final在数组中的应用在java中final关键字有第一无二的特性，就是只可以赋值一次，一旦...
java基础 ---- final关键字
m0_46523928的博客
02-05 114
java基础 ----权限关键词， final关键字，内部类，引用类型 权限关键词的理解概述: 权限关键词限制的是一个类对另一个类的访问，这两个类又按照同不同包，继不继承具体讨论出四种情况。public-->protected-->default-->private四种关键词的权限范围在四种情况中逐渐缩小。 权限关键词的使用概述： 权限关键词...
day11 05 final关键字用于修饰成员变量
08-31
day11_05_final关键字用于修饰成员变量
day11 03 final关键字用于修饰成员方法
08-31
day11_03_final关键字用于修饰成员方法
day11 04 final关键字用于修饰局部变量
08-31
day11_04_final关键字用于修饰局部变量
day11 01 final关键字概念与四种用法
08-31
day11_01_final关键字概念与四种用法
java学习day06——面向对象基础
DoubleYang的博客
03-06 1024
面向对象 public class Demo01PrintArray { public static void main(String[] args) { int[] array = {10, 20, 30, 40, 50}; // 使用面向过程 System.out.print("[");//去掉ln,不换行 for (in...
java学习day03——运算符
DoubleYang的博客
03-01 492
运算符 加 + 减 - 乘 * 除 / 整数除以整数，得到的仍是整数，只看商，不看余数 取模 % 注意事项 一旦运算中有不同类型的数据，结果将会是范围大的 // int+double --> double +double double result = a+2.5; 加法 有三种常见用法 数值的加法 对于char类型，计算之前，char会被提升为int，然后再计算...
java学习day05——数组、内存划分
DoubleYang的博客
03-03 428
数组 数组的特点： 数组是一种引用数据类型 数组中的多个数据类型必须统一 数组的长度在程序运行期间不可改变 数组的初始化： 动态初始化（指定长度） 数据类型[] 数组名称 = new 数据类型[数组长度]; 静态初始化（指定内容） 数据类型[] 数组名称 = new 数据类型[] {元素1,元素2,…}; 注意事项：虽然静态初始化没直接告诉长度，但是根据大括号里面元素的具体内容...
java学习day08——字符串、static关键字
DoubleYang的博客
03-08 342
文章目录字符串字符串的特点字符串的常见3+1种方式三种构造方法：一种直接创建：字符串的常量池字符串常用方法字符串之间的比较字符串的获取相关方法字符串的截取方法字符串的转换相关方法字符串的分割方法static关键字——数据共享static关键字修饰成员static关键字修饰成员方法静态static的内存图静态代码块数组工具类Arrays数学工具类math 字符串 字符串的特点 字符串的内容永不可变...
java学习day02——java数据类型
DoubleYang的博客
02-29 340
java程序开发三步骤：编写、编译、运行 .java -> .class(java字节码文件) javac.exe编译 java.exe运行 HelloWorld代码 （1）编写 用记事本编写，修改文件后缀名为.java，文件名与程序名一定严格一致（注意大小写） //多行注释 /* 第一行的第三个单词必须和所在的文件名称完全一样，大小写也要一样 public class后面代表定...
Java常见问题汇总
DoubleYang的博客
03-25 278
Integer和int的区别 Integer是int的包装类（引用数据类型），int是基本数据类型 既然Integer是类，那么Integer变量必须先实例，而int可以直接使用 因为Integer是包装类，所以有很多自带方法（如hashCode、toHexString），而int只能使用±*/等操作 Integer类中“==”用于判断两个Integer对象的地址是否相同，如要判断两个Integ...
java学习day07——常用的API
DoubleYang的博客
03-07 263
常用的API API（Application Programming Interface），应用编程接口 JDK API 1.6.0中文版 Scanner类 Scanner类的功能：可以实现键盘输入数据，到程序当中。 引用类型的一般使用步骤： 导包 import 包路径.类名称; 只有java.lang包下的内容不需要导包，其他的包都需要import语句。 创建 类名称 对象名 = new...
java学习day14——StringBulider、集合、Iterator迭代器、泛型
DoubleYang的博客
03-22 262
文章目录StringBuilder类集合Collection集合框架Colletion常用功能Iterator迭代器增强for泛型使用泛型的好处定义和使用含有泛型的类 StringBuilder类 String类： 字符串常量，创建后不可更改，字符串的底层是一个被final修饰的数组 private final byte[] value; StringBuilder类： 字符串缓冲区，可以提高字符...
java学习day01——java基础知识
DoubleYang的博客
02-29 259
十进制与二进制的转换 十进制转二进制：辗转相除法，将需要被转换的十进制不断除2，余数写在旁边，辗转相除直到除数是0 位与字节 位：bit，一个数字0或1，代表一位 字节：byte，八位为一个字节，字节是数据存储的最小单位 命令提示符 cd 文件夹 到某一文件夹 cd 文件夹1、文件夹2、文件夹3 进入多级文件夹 cd… 回到上一级 cd\ 回到根路径 dir 查看当前文...
Java接口与多态：final关键字的应用
在Java编程中，"day10-final、接口、多态.pdf"文档主要探讨了Java中的关键概念，包括final关键字、接口和多态。这些内容对于理解Java语言的封装和面向对象原则至关重要。 首先，final关键字被用来表示"不可变性"，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值