自学Java第11Day

已于 2024-07-20 00:36:08 修改
阅读量738 收藏 4
点赞数 13
文章标签： java 开发语言
于 2024-07-20 00:33:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Directionboy/article/details/140553259
版权

学习目标：面向对象进阶

学习内容：包、final、权限修饰符、代码块、抽象类、接口

学习时间：

     下午 3 点-下午 6 点

学习产出：

什么的包？

        包就是文件夹。用来管理各种不同功能的Java类，方便后期代码维护。

        包名的规则：公司域名反写+包的作用，需要全部英文小写，见名知意。

什么是全类包？

        包名+类名

使用其他类的规则

        使用同一个包中的类时，不需要导包。

        使用java.lang包中的类时，不需要导包。

         其他情况都需要导包。

         如果同时使用两个包中的同名类，需要用全类名。

final

        final修饰方法：表明该方法是最终方法，不能被重写。
        final修饰类：表明该类是最终类，不能被继承。
        final修饰变量：叫做常量，只能被赋值一次。

        此时就可发现父类中的show()方法被final修饰，子类无法重写父类中的方法。 

        此代码中就可发现被final修饰的变量，不能被修改。 

常量：

        实际开发中,常量一般作为系统的配置信息,方便维护,提高可读性。

        常量的命名规范：

                单个单词：全部大写。

                多个单词：全部大写,单词之间用下划线隔开。

细节:

        final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。

        final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，对象内部的可以改变。 

public class Test {
    public static void main(String[] args) {
        //创建对象
        final Student S = new Student("旭哥", 23);
        //记录的地址值不能发生改变,内部的属性值还是可以改变的
        // S = new Student();
        S.setName("蛋姐");
        S.setAge(21);
        System.out.println(S.getName() + ", " + S.getAge());

        //数组
        final int[] ARR = {1, 2, 3, 4, 5};
        ARR[0] = 10;
        ARR[1] = 20;

        //遍历数组
        for (int i = 0; i < ARR.length; i++) {
            System.out.println(ARR[i]);
        }
    }
}

运行结果：

蛋姐, 21
10
20
3
4
5

final应用场景

        在之前我们写过一个学生管理系统，在代码中有一段代码实现的是目录，为了让代码阅读性更强，可将switch循环中的case选项final私有化定义，可将数字命名为可读性更强的英文。

权限修饰符

        权限修饰符:是用来控制一个成员能够被访问的范围的。

        可以修饰成员变量,方法,构造方法,内部类。

权限修饰符的分类

        有四种作用范围由小到大(private<空着不写<protected<public)

修饰符同一个类中同一个包中
其他类		不同包下的
子类		不同包下的
无关类
private\sqrt{}
空着不写\sqrt{}\sqrt{}
protected\sqrt{}\sqrt{}\sqrt{}
public\sqrt{}\sqrt{}\sqrt{}\sqrt{}

代码块

       局部代码块： 局部代码块是在方法内部定义的，它的作用域仅限于该方法内。局部代码块通常用于定义方法内的控制流，例如条件语句（if-else）、循环（for、while）等。

public class Test {
public static void main(String[] args) {
        {
            int a = 10;
            System.out.println(a);
        }
    }
}

        构造代码块：构造代码块是在类中定义的，它在类的构造函数之前执行。如果有多个构造函数，构造代码块会在每个构造函数执行之前运行。它用于初始化类的实例变量。

public class Student {
    private String name;
    private int age;
    {
        System.out.println("开始创建对象了");
    }

    public Student() {
        System.out.println("空参构造");
    }

    public Student(String name, int age) {
        System.out.println("有参构造");
        this.name = name;
        this.age = age;
    }

    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 class Test {
    public static void main(String[] args) {
        //创建对象
        Student s=new Student();
        Student s2=new Student("旭哥",23);
    }
}

运行结果：

开始创建对象了
空参构造
开始创建对象了
有参构造

        静态代码块：静态代码块是在类中定义的，它在类被加载到JVM时执行一次，且仅执行一次。它主要用于初始化类的静态变量。

public class Student {
    private String name;
    private int age;
    static {
        System.out.println("开始创建对象了");
    }

    public Student() {
        System.out.println("空参构造");
    }

    public Student(String name, int age) {
        System.out.println("有参构造");
        this.name = name;
        this.age = age;
    }

    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 class Test {
    public static void main(String[] args) {
        //创建对象
        Student s=new Student();
        Student s2=new Student("旭哥",23);
    }
}

运行结果：

开始创建对象了
空参构造
有参构造

抽象类

        抽象方法：将共性的行为(方法)抽取到父类之后。由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。

        抽象类：如果一个类中存在抽象方法，那么该类就必须声明为抽象类。

抽象类和抽象方法的定义格式

        抽象方法的定义格式：
                public abstract      返回值类型 方法名(参数列表);
        抽象类的定义格式：
                public abstract class     类名

public abstract class Person {
    public abstract void work();
}

抽象类和抽象方法的注意事项

        抽象类不能实例化。
        抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
        可以有构造方法。
        抽象类的子类：
                要么重写抽象类中的所有抽象方法。
                要么是抽象类。

练习：编写带有抽象类的标准Javabean类

青蛙frog                属性:名字,年龄                        行为:吃虫子,喝水

狗Dog                   属性:名字,年龄                        行为:吃骨头,喝水

山羊Sheep            属性:名字,年龄                        行为:吃草,喝水

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public  Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 abstract void eat();
    public void drink(){
        System.out.println("动物在喝水");
    }
}

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗在啃骨头");
    }
}

public class Frog extends Animal{
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }
}

public class Sheep extends Animal{
    public Sheep() {
    }

    public Sheep(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("山羊在吃草");
    }
}

public class Test {
    public static void main(String[] args) {
        Sheep s=new Sheep("喜羊羊",2);
        s.eat();
        s.drink();
    }
}

运行结果：

山羊在吃草
动物在喝水

接口

        在Java中，接口（Interface）是一种引用类型，它定义了一组方法规范，这些方法规范可以由实现该接口的类来具体实现。接口是Java面向对象编程的核心概念之一，它提供了一种机制来实现抽象和多态。

接口的定义和使用

        接口用关键字interface来定义
                public interface 接口名{}
        接口不能实例化

        接口和类之间是实现关系,通过implements关键字表示
                public class 类名 implements 接口名{}
        接口的子类(实现类)
                要么重写接口中的所有抽象方法
                要么是抽象类

注意1：接口和类的实现关系,可以单实现,也可以多实现。
        public class 类名 implements 接口名1,接口名2{}

注意2：实现类还可以在继承一个类的同时实现多个接口。
        public class 类名 extends 父类 implements 接口名1,接口名2}

练习：编写带有接口和抽象类的标准Javabean类

青蛙           属性：名字，年龄        行为：吃虫子，蛙泳

狗               属性：名字，年龄        行为：吃骨头，狗刨

兔子            属性：名字，年龄        行为：吃胡萝卜

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public  Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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 abstract void eat();

}

public interface Swim {
    public abstract void swim();
}


public class Dog extends Animal implements Swim{
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗在啃骨头");
    }

    @Override
    public void swim() {
        System.out.println("狗在狗刨");
    }
}


public class Frog extends Animal implements Swim{
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}

public class Frog extends Animal implements Swim{
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}

public class Test {
    public static void main(String[] args) {
        Rabbit s=new Rabbit("喜羊羊",2);
        System.out.println(s.getName()+","+s.getAge());
        s.eat();
        Dog d=new Dog("维鲁斯",3);
        System.out.println(d.getName()+","+d.getAge());
        d.eat();
        d.swim();
    }
}

运行结果：

喜羊羊,2
兔子在吃胡萝卜
维鲁斯,3
狗在啃骨头
狗在狗刨

接口中成员的特点

         成员变量
                只能是常量
                默认修饰符：public static final
        构造方法
                没有

        成员方法
                只能是抽象方法
                默认修饰符：public abstract

        JDK7以前：接口中只能定义抽象方法。

        JDK8的新特性：接口中可以定义有方法体的方法。

        JDK9的新特性：接口中可以定义私有方法。

接口和类之间的关系

        类和类的关系
                继承关系，只能单继承，不能多继承但是可以多层继承
         类和接口的关系
                实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
         接口和接口的关系
                继承关系，可以单继承，也可以多继承

练习：编写带有接口和抽象类的标准Javabean类

        我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。

        为了出国交流，跟乒乓球相关的人员都需要学习英语。

        请用所有知识分析，在这个案例中，哪些是具体类，哪些是抽象类,哪些是接口?

                乒乓球运动员：姓名，年龄，学打乒乓球，说英语

                篮球运动员：姓名，年龄，学打篮球

                乒乓球教练：姓名，年龄，教打乒乓球，说英语

                篮球教练：姓名，年龄，教打篮球

public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

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

    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 interface English {
    public abstract void speakElish();
}
public class baskerballSporter extends Sporter{
    public baskerballSporter() {
    }

    public baskerballSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学习打篮球");
    }
}

public class basketballCoach extends Coach{
    public basketballCoach() {
    }

    public basketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练在教打篮球");
    }
}

public abstract class Coach extends Person{
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

public class pingpongCoach extends Coach implements English{
    @Override
    public void speakElish() {
        System.out.println("乒乓球教练在学习英语");
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练在教打乒乓球");
    }
}

public class pingpongSporter extends Sporter implements English{
    public pingpongSporter() {
    }

    public pingpongSporter(String name, int age) {
        super(name, age);
    }

    @Override
    public void speakElish() {
        System.out.println("乒乓球运动员在说英语");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学习打乒乓球");
    }
}

import a10demo2.Animal;

public abstract class Sporter extends Person{
    public Sporter() {
    }

    public Sporter(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

public class Test {
    public static void main(String[] args) {
        pingpongSporter pps=new pingpongSporter("王楚钦",23);
        System.out.println(pps.getName()+", "+pps.getAge());
        pps.study();
        pps.speakElish();
        System.out.println("----------------------------");
        basketballCoach bbc=new basketballCoach("科比",41);
        System.out.println(bbc.getName()+", "+bbc.getAge());
        bbc.teach();
    }
}

运行结果：

王楚钦, 23
乒乓球运动员在学习打乒乓球
乒乓球运动员在说英语
----------------------------
科比, 41
篮球教练在教打篮球

JDK8以后接口中新增的方法

       1、 允许在接口中定义默认方法，需要使用关键字 default修饰

                作用:解决接口升级的问题

        接口中默认方法的定义格式：
                格式：public default 返回值类型 方法名(参数列表){}
                范例：public default void show(){ }

        接口中默认方法的注意事项：
        默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字。

         public可以省略,default不能省略。
        如果实现了多个接口,多个接口中存在相同名字的默认方法,子类就必须对该方法进行重写。

        2、允许在接口中定义定义静态方法，需要用static修饰

        接口中静态方法的定义格式：
                格式：public static 返回值类型 方法名(参数列表){}
                范例：public static void show(){ }

        接口中静态方法的注意事项:
                静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
                public可以省略，static不能省略

JDK9新增的方法

        接口中私有方法的定义格式：

                格式1：private 返回值类型 方法名(参数列表){}
                范例1：private void show(){ }

                格式2：private static 返回值类型 方法名(参数列表){}
                范例2：private static void method(){ }

适配器设计模式

        设计模式(Design pattern)是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
        使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

        简单理解：设计模式就是各种套路。

        适配器设计模式：解决接口与接口实现类之间的矛盾问题。

全聚德一级码师
关注
  • 13
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 自学 day04
weixin_68572541的博客
04-17 309
进制 在ideal中默认为十进制 二进制：数值前面加0b开头 八进制：数值前面加0开头 十六进制：数值前面加0x开头 注意：加入了进制标识符，但是在控制台上还是打印为十进制数据。- 进制转换 二进制到十进制的转换 公式：系数*基数的权次幂相加 系数：每一【位】上的数 基数：几进制就是几 权：从数值右侧，以0开始，逐次+1。 例如：二进制：0b100 十进制：0*2^0 = 0 0*2^1 = 0 0*2^2 = 4 三组相加为4 例如：十六进制到十进制 十六进制：
Java自学 day06
weixin_68572541的博客
04-20 143
学习目标： 提示：这里可以添加学习目标 例如： 一周掌握 Java 入门知识 学习内容： 搭建 Java 开发环境 掌握 Java 基本语法 掌握条件语句 掌握循环语句 学习时间： 提示：这里可以添加计划学习的时间 例如： 周一至周五晚上 7 点—晚上9点 周六上午 9 点-上午 11 点 周日下午 3 点-下午 6 点 学习产出： 提示：这里统计学习计划的总量 例如： 技术笔记 2 遍 CSDN 技术博客 3 篇 习的 vlog 视频 1 个 ...
自学Java打卡第2Day
Directionboy的博客
07-09 134
一星期学完面向对象。
自学Java第7Day
Directionboy的博客
07-15 510
为学生管理系统书写一个登录、注册、忘记密码的功能。只有用户登录成功之后，才能进入到学生管理系统中进行增删改查操作。
自学Java Day11
weixin_68572541的博客
04-30 635
学习目标： java继承 学习内容： 1.继承概述： 学习时间： 提示：这里可以添加计划学习的时间 例如： 周一至周五晚上 7 点—晚上9点 周六上午 9 点-上午 11 点 周日下午 3 点-下午 6 点 学习产出： 提示：这里统计学习计划的总量 例如： 技术笔记 2 遍 CSDN 技术博客 3 篇 习的 vlog 视频 1 个 ...
自学Java-day01(初学Java)
Link的博客
05-04 362
Java第一章一、Java 可以做什么？二、什么是程序？三、Java 起源与演变3.1、起源3.2、演变四、Java 体系与特点五、Java 的特性六、Java 跨平台原理七、Java 技术的两种核心机制7.1、Java 虚拟机(Java Virtual Machine) JVM7.2、垃圾回收器(GC）八、Java程序运行过程 一、Java 可以做什么？ 开发桌面应用程序： 银行软件、商场结算软件 开发面向 Internet 的 web 应用程序： 门户网站（工商银行）、网上商城、阿里巴巴、电子商
自学java （day11）：类和对象
qq_60943111的博客
11-04 125
【代码】自学java （day11）：类和对象。
自学Java第十二天小练习
二十四划生的博客
09-03 67
输入两个正整数 m和 n(1
Java-SE自学day01_数据类型
qq_44671988的博客
03-04 1244
这些基本数据类型在 Java 编程中非常基础且重要，它们用于定义变量、数组、方法参数和返回值等。了解它们的取值范围和特性有助于编写高效且正确的代码。Java中有八种基本数据类型，它们分为四大类：整型、浮点型、字符型和布尔型。
第十次开始自学Java的记录day01——spring5的第一个程序
Stitch0302的博客
05-10 78
自娱自乐
自学java day02.md
08-29
自学java day02.md
自学Java第三天 day03.java
08-30
自学Java第三天 day03.java
java自学笔记day2
02-12
Java自学笔记Day2主要涉及了两个核心主题：二进制的使用和运算符，特别是算术运算符。在深入理解这些概念之前，首先要明白Java是一种广泛使用的后端开发语言，它构建于Apache等开源基础设施之上，因此掌握这些基础...
java基础自学课程,day03,文档
12-11
本文档详细介绍了引用数据数据类型（Scanner、Random）以及流程控制语句（if、for、while、dowhile、break、continue），并有案例解析与实现
《JavaSE》---6.＜基础语法（Java三大程序控制结构）＞
m0_73456341的博客
07-14 831
本篇博客主要讲解Java基础语法中的三大结构，一种顺序结构、两大分支结构i（if-else、swich-case）、四大循环结构（while、do while、fot、foreach）
Spring Security 授权
persistence_PSH的博客
07-14 904
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 1025
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
day04：Redis和店铺营业状态设置
最新发布
m0_69266818的博客
07-15 834
介绍了Redis命令和用java操作redis还有营业额状态接口的书写

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值