Java Day11

最新推荐文章于 2024-07-24 17:27:32 发布
最新推荐文章于 2024-07-24 17:27:32 发布
阅读量103 收藏
点赞数 1
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38689352/article/details/107390688
版权

第一章 final关键字

1.1 概述

学习了继承之后，我们知道，子类可以在父类的基础上改写父类的内容，比如方法的重写。但是我们不能随意的去改写类中的内容，为了避免这种情况，Java提供了final关键字，用于修饰不可变内容。

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

1.2 使用方式

  • 修饰类
    • 格式如下：
final class 类名 {

}
  • 修饰方法
    • 格式如下：
修饰符 final 返回值类型 方法名(参数列表) {
    // 方法体
}
  • 修饰变量
  • 局部变量——基本类型
    • 基本类型的局部变量，被final修饰后，只能赋值一次，不能再改变。代码如下：
public class Demo01Final {

    public static void main(String[] args) {
        int num1 = 10;
        System.out.println(num1);
        num1 = 20;
        System.out.println(num1);

        // 一旦使用final用来修饰局部变量，那么这个变量就不能进行更改。
        // 一次赋值，终身不变
        final int num2 = 200;
        System.out.println(num2);  // 200

        // 错误写法
//        num2 = 230;

        // 正确写法，只要保证只有唯一一次赋值即可。
        final int num3;
        num3 = 30;
}
  • 局部变量——引用类型
    • 引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再改变。但是不影响对对象内部的成员变量值的修改，代码如下：
public class Demo01Final {

    public static void main(String[] args) {
        // 对于基本类型来说，不可变说的是变量当中的数据不可变。
        // 对于引用类型来说，不可变说的是变量当中的地址值不可改变。
        Student stu1 = new Student("tiger");
        System.out.println(stu1.getName());
        System.out.println(stu1);
        stu1 = new Student("trony");
        System.out.println(stu1);
        System.out.println(stu1.getName());

        final Student stu2 = new Student("hhhh");
        System.out.println(stu2.getName());
        // stu2 = new Student("llll");  // 错误写法！final的引用类型变量地址不可改变
        stu2.setName("hahah");
        System.out.println(stu2.getName());

    }
}
  • 成员变量
    • 成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
      • 显示初始化
      • 构造方法初始化
/*
* 对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变的。
*
* 1、由于成员变量具有默认值，所以用了final之后就必须手动赋值，不能在给默认值了。
* 2、对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一。
* 3、必须保证类中的所有重载的构造方法，最终会对final的成员变量进行赋值。
* */

public class Person {
    private final String name;

    public Person() {
        name = "aaa";
    }

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

    public String getName() {
        return name;
    }
}

第二章 权限修饰符

2.1 概述

在java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限。

  • public：公共的
  • protected：受保护的
  • default：默认的（不写修饰符）
  • private：私有的

2.2 不同权限的访问能力

可见，public具有最大权限，private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

  • 成员变量使用private，隐藏细节。
  • 构造方法使用public，方便创建对象。
  • 成员方法使用public，方便调用。

第三章 内部类

3.1 概述

  • 什么内部类：将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

3.2 成员内部类

  • 成员内部类：定义在类方法外的类。
  • 定义格式：
class 外部类 {
    class 内部类 {
    
    }
}
  • 在描述事物时，若有一个事物内部类还包含其他事物，就可以使用内部类这种结构。比如：汽车类Car中包含发动机类Engine，这时，Engine就可以使用内部类来描述，定义在成员变量。
  • 代码举例：
class Car {  // 外部类
    class Engine {  // 内部类
                    
    }
}
  • 访问特点：
    • 内部类可以直接访问外部类的成员，包括私有成员。
    • 外部类要访问内部类的成员，必须要建立内部类的对象。
  • 创建内部类的格式
外部类名称.内部类名称 对象名 = 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("外部类方法");
        Heart heart = new Heart();
        heart.beat();
    }


    public String getName() {
        return name;
    }

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

定义测试类：

/*
* 如果一个事物的内部包含另一个事物，那么这就是一个类内部包含另一个类
* 例如：身体和心脏，汽车和发动机
*
* 分类：
*   成员内部类
*   局部内部类（包含匿名内部类）
*
* 成员内部类的定义格式：
* 修饰符 class 外部类名称 {
*   修饰符 class 内部类名称 {
*       // ...
*   }
* }
*
* 注意，内用外，随意访问，外用内，需要内部类对象。
*
* 如何使用成员内部类：
*   1、间接方式：在外部类的方法中，使用内部类，然后main只是调用外部类的方法。
*   2、直接方式：公式：外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
* */

public class Demo01InnerClass {

    public static void main(String[] args) {
        Body body = new Body();  // 外部类对象
        body.methodBody();  // 通过外部类的对象，调用外部类的方法，里面间接使用内部类方法
        System.out.println("======================");

        // 按照公式来写
        Body.Heart heart = new Body().new Heart();
        heart.beat();

    }


}
  • 注意：内部类仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号。

3.3 匿名内部类

  • 匿名内部类：是内部类的简化写法，他的本质是一个带具体实现的父类或者父接口的匿名的子类对象。
  • 在开发中最常用到的内部类就是匿名内部类，以接口举例，当使用一个接口时，似乎要进行以下几个步骤：
    • 定义子类
    • 重写接口中的方法
    • 创建子类对象
    • 调用重写后的方法
  • 前提：匿名内部类必须继承一个父类或者一个父接口。
  • 格式；
new 父类名或者接口名() {
    // 方法重写
    @Override
    public void method() {
        // 执行语句
    }
};
  • 使用方式：以接口为例，代码如下：

定义接口：

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

创建内部类，并调用：

public class DemoMain {
    public static void main(String[] args) {

        // 使用匿名内部类，但不是匿名对象，对象名就叫obj
        MyInterface obj = new MyInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类。");
            }
        };
        obj.method();

        // 使用了匿名内部类，而且省略了对象名称，也是匿名对象。
        new MyInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类。");
            }
        }.method();
    }
}

第四章 引用类型用法总结

在实际开发中，引用类型的使用非常重要，也是非常普遍的。我们可以在理解基本类型的使用方式的基础上，进一步去掌握引用类型的使用方式。基本类型可以作为成员变量，作为方法的参数，作为方法的返回值，那么当然引用类型也是可以的。

4.1 class作为成员变量

  • 在定义一个类Hero时，代码如下：
// 游戏当中的英雄角色类
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 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 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();
    }
}

4.2 interface作为成员变量

接口是对方法的封装，对应游戏当中，可以看作是扩展角色的技能，所以如果象扩大技能，我们在Hero中可以增加接口作为成员变量，来设置不同的技能。

定义接口：

public interface Skill {

    // 释放技能的抽象方法
    void use();
}

定义英雄类：

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

        // 还可以改为使用匿名内部类和匿名对象
        hero.setSkill(new Skill() {
            @Override
            public void use() {
                System.out.println("Biu-Biu-Biu----");
            }
        });
        hero.attack();
    }
}
  • 我们使用接口，作为成员变量，以便随时更换技能，这样的设计更为灵活，增强了程序的扩展性。
  • 接口作为成员变量时，对他进行赋值的操作，实际上，是赋给它该接口的一个子类对象。

4.3 interface作为方法参数和返回值

当接口作为方法的参数时，需要传递它的子类对象，当接口作为方法的返回值时，返回其子类对象。

例如：

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("tiger");
        list.add("trony");
        list.add("hhhhh");
        return list;
    }
}

 

哈哈哈捧场王
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java day of month_Java MonthDay withDayOfMonth()用法及代码示例
weixin_31597865的博客
02-23 1673
MonthDay类的withDayOfMonth(int dayOfMonth)方法用于将传递的dayOfMonth用作参数来更改MonthDay对象的day-of-month，然后该方法返回更改后的MonthDay的副本。如果day-of-month值在指定的月份后无效，则抛出异常改变操作。用法:public MonthDay withDayOfMonth(int dayOfMonth)参数：此...
Java day11
weixin_53515338的博客
03-30 52
回顾 标识符 关键字 字面值 数据类型 进制转换 字符编码 变量 数据类型详解 运算符类型 控制语句（最重要的逻辑） 选择结构： if
Day1-Java入门
热门推荐
aiains的博客
06-27 3万+
CMD常用命令； 用CMD运行电脑程序以及对应的环境配置； 用记事本编写helloworld，用CMD运行； Java环境变量的配置； Notepad++的使用； 初步了解JDK和JRE。
JAVA学习day6
qq_54395021的博客
04-30 2253
多线程：在身边的应用 可以边 看电影边 听音乐边 打游戏 JDK：java development kit （java开发者工具） JRE：java runtime environment （java运行环境） JVM：java virtual machine （java虚拟机）
Java day12
qq_43541224的博客
10-29 178
JAVA API api的使用 Object类 Scanner String
Javaday02训练
02-08
Java Day02训练是针对Java初学者或有一定基础的学习者设计的一次深入学习活动，旨在强化和巩固Java编程的基础知识。在这个训练中，你将接触到一系列关键的Java编程概念和技术，包括但不限于变量、数据类型、控制流程...
day11 java
11-11
【Java线程详解】 在Java编程中，线程是程序执行的基本单位，它允许一个程序在单个进程中并发地执行多个任务。理解线程的概念及其使用对于开发高效的多任务应用程序至关重要。 **线程的概述** - **进程**：运行中...
day11-多线程 java
06-10
day11-多线程 java
Java入门基础学习资料day11
10-22
此java基础课程，适合0基础小白，课程一共11天...day11【final、权限、内部类、引用类型】 此课程全部课程资料获取： JavaEE基础学习资料地址汇总：https://blog.csdn.net/weixin_46271129/article/details/133979063
day05集合 java
06-11
day05集合 java
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1136
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
redis+spring面试题
github_36510643的博客
07-21 406
redis+spring面试题
Java-Lambda
lizhiwei21的博客
07-21 444
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 774
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 788
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件
最新发布
weixin_43561432的博客
07-24 140
【代码】Java读取文件中多个JSON对象，并且16进制字符串和byte相互转换，将byte转为16进制字符串并写入json文件。
java算法day19
TOMOT77的博客
07-20 326
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
华为OD机试 - 分披萨 - 递归（Java 2024 D卷 200分）
学Java，找哪吒
07-21 974
递归算法通过函数调用自身解决问题，每次递归调用都处理问题的一个子部分，直到达到基准条件，从而构建最终解。
【Java并发编程之美 | 第三篇】Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
踢桃的成长之路
07-21 826
Java 并发包中锁原理剖析之AQS、ReentrantLock独占可重入锁
java DAY_OF_MONTHY
07-22
Java中的DAY_OF_MONTH常量是一个字段，用于表示一个日期中的月份中的天数。它位于java.util.Calendar类中，可以通过Calendar类的get方法来获取： ```java import java.util.Calendar; public class Main { public...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值