JavaSE进阶（day02，复习自用）

最新推荐文章于 2025-12-27 15:45:53 发布

原创最新推荐文章于 2025-12-27 15:45:53 发布 · 338 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

JavaSE进阶专栏收录该内容

14 篇文章

订阅专栏

JavaSE面向对象进阶day02

包
权限修饰符
final
常量
枚举
抽象类
接口

包

包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。
在这里插入图片描述

权限修饰符

权限修饰符：是用来控制一个成员能够被访问的范围。
可以修饰成员变量，方法，构造器，内部类，不同权限修饰符修饰的成员能够被访问的范围将受到限制。
权限修饰符：有四种作用范围由小到大（private -> 缺省 -> protected - > public ）
在这里插入图片描述

final

final的作用
final 关键字是最终的意思，可以修饰（类、方法、变量）
修饰类：表明该类是最终类，不能被继承。
修饰方法：表明该方法是最终方法，不能被重写。
修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)。

public class Test {
    public static void main(String[] args) {
        //目标：记住final的语法
        //1.final修饰类，类不能被继承
        //2.final修饰方法，方法不能被重写
        //3.final修饰变量，总规则：变量有且仅能被赋值一次。


    }
}

//final class Animal{
//
//}
//class Wolf extends Animal{
//
//}

class People{
    public final void eat(){
        System.out.println("人都要吃东西~~");
    }
}

class Student extends People{
//    @Override
//    public void eat() {
//        System.out.println("学生吃得很多~~");
//    }
}

public class Test2 {

    /**
     * 二：修饰静态成员变量(public static final 修饰的也称为常量了)
     */
    public static final String schoolName = "黑马";

    /**
     *三：修饰实例成员变量(几乎不用)
     */
    private final String name = "猪刚鬣";


    public static void main(String[] args) {
        //目标：理解final修饰变量的作用：总规则：变量有且仅能被赋值一次。
        //变量有几种：
        //1.局部变量
        //2.成员变量
        //      --实例成员变量
        //      --静态成员变量

        //一：修饰局部变量
        final double rate = 3.14;
        //rate = 3.19;//第二次赋值了
        buy(0.8);


        //schoolName = "黑马程序员";//第二次赋值了

        Test2 t = new Test2();
        System.out.println(t.name);
        //t.name = "天蓬元帅";

        //注意：final修饰引用类型的变量，其地址值不能改变，但是指向的对象的内容是可以改变的。
        final Teacher t2 = new Teacher("学习，授课，吹吹水~~");
        //t2 = null;//报错，第二次赋值了
        System.out.println(t2.getHobby());
        t2.setHobby("运动");
        System.out.println(t2.getHobby());


    }

    public static void buy(final double z){
        //z = 0.1;//相当于第二次赋值了，因为传入的参数已经有值了
    }

}


class Teacher{
    private String hobby;

    public Teacher(String hobby) {
        this.hobby = hobby;
    }

    public String getHobby() {
        return hobby;
    }

    public void setHobby(String hobby) {
        this.hobby = hobby;
    }

final修饰变量的注意
final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。
final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。

常量

在这里插入图片描述

枚举

枚举的概述
枚举是Java中的一种特殊类型
枚举的作用：“是为了做信息的标志和信息的分类”。
在这里插入图片描述

抽象类

在这里插入图片描述

1、抽象类、抽象方法是什么样的？
都是用abstract修饰的；抽象方法只有方法签名，不能写方法体。
一个类中定义了抽象方法，这个类必须声明成抽象类。
2、抽象类基本作用是啥？
作为父类，用来被继承的。
3、继承抽象类有哪些要注意？
一个类如果继承了抽象类，那么这个类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

抽象类的特征、注意事项

类有的成员（成员变量、方法、构造器）抽象类都具备
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
不能用abstract修饰变量、代码块、构造器。
最重要的特征：得到了抽象方法，失去了创建对象的能力（有得有失）
final和abstract是什么关系？
互斥关系
abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。
抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。


public class Test {
    public static void main(String[] args) {
        //目标：理解抽象类的特征和注意事项
        //1.类有的东西，抽象类都有。
        //2.抽象类中可以没有抽象方法，但是有抽象方法的必须是抽象类。
        //3.一个类继承了抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。
        //4.抽象类不能创建对象,为什么？
//        Animal a = new Animal();//报错
        //反证法：假如抽象类可以创建对象
//        a.run();//run方法连方法体都没有！因此抽象类不能创建对象。

//        Card c = new Card();//不行的，抽象类不能创建对象（这个观点不能动摇）。


    }
}

abstract class Card{
    private String name;

    public String getName(){
        return name;
    }

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



abstract class Animal{
    public abstract void run();
    public abstract void eat();
}

class Cat extends Animal{

    @Override
    public void run() {

    }

    @Override
    public void eat() {

    }
}

抽象类的应用知识：模板方法模式

在这里插入图片描述

public abstract class Student {
    /**
     * 正式：声明了模板方法模式
     */
    public final void write(){
        System.out.println("\t\t\t《我的爸爸》");
        System.out.println("你的爸爸是啥样，来说说：");
        //正文(每个子类都要写，每个子类写的情况不一样)
        //因此，模板方法把正文部分定义成抽象方法，交给具体的子类来完成
        System.out.println(writeMain());


        System.out.println("我的爸爸简直太好了~~");
    }

    public abstract String writeMain();


}

public class StudentChild extends Student {


    @Override
    public String writeMain() {

        return "我的爸爸太牛b了，他总是买东西给我吃";
    }
}

public class StudentMiddle extends Student {

    @Override
    public String writeMain() {
        return "我的爸爸也很牛，开车都不看红绿灯的，下辈子还要做他儿子";
    }
}

public class Test {
    public static void main(String[] args) {
        //目标：理解模板方法模式的思想和使用步骤
        StudentMiddle s = new StudentMiddle();
        s.write();

        StudentChild s2 = new StudentChild();
        s2.write();
    }
}

模板方法我们是建议使用final修饰的，这样会更专业，那么为什么呢？
答：模板方法是给子类直接使用的，不是让子类重写的，
一旦子类重写了模板方法，则模板方法就失效了，因此，加上final后可以防止子类重写了模板方法，这样更安全、专业。

接口

接口概述、特点

在这里插入图片描述

/**
 * 声明了一个接口:体现一种规范，规范一定是公开的。
 */
public interface InterfaceDemo {
    //目标：接口中的成分特点：JDK 8之前接口中只能有抽象方法和常量。
    //1.常量
    //注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public static final可以省略不写。
    String SCHOOL_NAME = "黑马程序员";
    //public static final String SCHOOL_NAME = "黑马程序员";

    //2.抽象方法
    //注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public abstract可以省略不写。
    void run();
    //public abstract void run();
    void eat();
    //public abstract void eat();
}

接口的基本使用：被实现

在这里插入图片描述

/**
 * 规范
 */
public interface SportMan {
    void run();
    void competition();
}

public interface Law {
    void rule();//遵纪守法
}

/**
 * 实现类
 */
public class PingPongMan implements SportMan,Law{
    private String name;

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

    @Override
    public void run() {
        System.out.println(name + "必须跑步训练!");
    }

    @Override
    public void competition() {
        System.out.println(name + "要参加比赛");

    }

    @Override
    public void rule() {
        System.out.println(name + "必须守法~~");
    }
}


public class Test {
    public static void main(String[] args) {
        //目标：理解接口的基本使用：被类实现。
        PingPongMan p =new PingPongMan("张继科");
        p.run();
        p.competition();
    }
}

运行结果：
在这里插入图片描述

补充知识：接口与接口的多继承

基本小结
类和类的关系：单继承。
类和接口的关系：多实现。
接口和接口的关系：多继承，一个接口可以同时继承多个接口。

接口多继承的作用
规范合并，整合多个接口为同一个接口，便于子类实现。

public interface Law {
    void rule();
}

public interface People {
    void eat();
    void sleep();
}

/**
 * 接口可以多继承，一个接口可以同时继承多个接口。
 */

public interface SportMan extends Law,People {
    void run();
    void competition();


}

/**
 * 一个实现类的：
 */

public class BasketBallMan implements SportMan{


    @Override
    public void rule() {

    }

    @Override
    public void eat() {

    }

    @Override
    public void sleep() {

    }

    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

public class Test {
    public static void main(String[] args) {
        //目标：理解接口多继承的作用。

    }
}

补充知识：JDK8开始接口新增的方法

在这里插入图片描述

public interface SportManInter {
    /**
     * 1.JDK 8开始：默认方法(实例方法)
     * --必须default修饰，默认用public修饰
     * --默认方法，接口不能创建对象，这个方法只能过继给了实现类，由实现类的对象调用。
     */
    default void run(){
        go();
        System.out.println("跑得很快~~");
    }

    /**
     * 2.静态方法
     * 必须使用static修饰，默认用public修饰
     * --接口的静态方法，必须接口名自己调用。
     */
    public static void inAddr(){
        System.out.println("我们都在学习Java新增方法的语法，它是Java源码自己会用到的~~~");
    }

    /**
     * 3.私有方法(实例方法)
     * --JDK 1.9才开始支持的。
     * --必须在接口内部才能访问
     */
    private void go(){
        System.out.println("开始跑~~~");
    }


}

class PingPongMan implements SportManInter{
}

class Test{
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan();
        p.run();


        SportManInter.inAddr();
        //PingPongMan.inAddr();
    }
}

补充知识：使用接口的注意事项

接口的注意事项
1、接口不能创建对象
2、一个类实现多个接口，多个接口的规范不能冲突
2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。
3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
4、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。
5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。

public class Test {
    public static void main(String[] args) {
//        接口的注意事项
//        1、接口不能创建对象(接口更加彻底的抽象)

//        2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。


//        3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
        Cat c =new Cat();
        c.eat();


//        4、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。
//        5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
    }
}

interface A{
    static void test(){
        System.out.println("A");
    }
}

interface B{
    static void test(){
        System.out.println("B");
    }
}

/**
 *         2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。原因是接口的静态方法不能C调用，只能A调用A的，只能B调用B的
 *
 */
class C implements A,B{
    public static void main(String[] args) {

    }
}

//        3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
interface Food{
    default void eat(){
        System.out.println("接口中的吃方法~~");
    }
}
class Animal{
    public void eat(){
        System.out.println("父类动物吃~~");
    }
}
class Cat extends Animal implements Food{

}

//        4、一个类实现了多个接口，多个接口中存在同名的默认方法，可以不冲突，这个类重写该方法即可。
interface AA{
    default void go(){
        System.out.println("AA");
    }
}

interface BB{
    default void go(){
        System.out.println("BB");
    }
}

class CC implements AA,BB{

    @Override
    public void go() {

    }
}

//        5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
interface AAA{
    //int run();//这样下面会报错
    void run();
}

interface BBB{
    void run();
}

interface CCC extends AAA,BBB{

}