（1-4）Java Object类、Final、注解、设计模式、抽象类、接口、内部类

isyangli_blog2025-05-18 22:31

目录

[1. Object类](#1. Object类)

[1.1 equals](#1.1 equals)

[1.2 toString（）](#1.2 toString（）)

2.final关键字

3.注解

[4. 设计模式](#4. 设计模式)

[4.1 单例模式](#4.1 单例模式)

[4.1.1 饿汉式](#4.1.1 饿汉式)

[4.1.3 饿汉式 VS 懒汉式](#4.1.3 饿汉式 VS 懒汉式)

[5. 抽象类&抽象方法](#5. 抽象类&抽象方法)

[6. 接口](#6. 接口)

7.内部类

[7.1 成员内部类](#7.1 成员内部类)

[7.2 静态内部类](#7.2 静态内部类)

[7.3 方法内部类](#7.3 方法内部类)

[7.4 匿名内部类](#7.4 匿名内部类)

1. Object类

1.1 equals

重写Object 的equals方法，两种实现方式

1.2 toString（）

2.final关键字

3.注解

4. 设计模式

设计模式是基于场景的解决方案

4.1 单例模式
4.1.1 饿汉式

代码实现：

java 复制代码 
package org.example;

/**
 *   01   饿汉式 ： 创建对象实例的时候直接初始化
 *
 *   典型的空间换时间，类加载的的时候  ==>静态实例对象完成初始化操作
 */
public class SingletonOne {
    // 1. 创建类中的私有构造
    private SingletonOne(){
    }

    // 2. 创建改类型的私有静态实例   (创建并实例化)
    private static SingletonOne instance = new SingletonOne();

    // 3. 创建公有静态方法返回静态实例对象
    public static SingletonOne getInstance(){
        return instance;
    }
}

测试结果：

java 复制代码 
import org.example.SingletonOne;

public class test {
    public static void main(String[] args) {
//        SingletonOne one = new SingletonOne();
        SingletonOne one = SingletonOne.getInstance();
        SingletonOne two = SingletonOne.getInstance();
        System.out.println(one);  //org.example.SingletonOne@4554617c
        System.out.println(two);  //org.example.SingletonOne@4554617c
        System.out.println(one == two);      //true
        System.out.println(one.equals(two));   //true
    }
}

4.1.2 懒汉式

java 复制代码 
package org.example;

/**
 * 02 懒汉式
 *
 * 类内实例对象创建时并不初始化，直到第一次调用get方法时，才完成初始化操作
 * 用时间换取空间的一种编码模式
 */
public class SingletonTwo {
    // 01 创建私有构造方法
    private SingletonTwo(){
    }

    // 02 创建开放的静态方法提供实例对象
    public static SingletonTwo instance = null;

    // 03. 创建开放的实例方法提供实例对象
    public static SingletonTwo getInstance(){
        if(instance == null){
            instance = new SingletonTwo();
        }
        return instance;
    }
}

测试

java 复制代码 
import org.example.SingletonOne;
import org.example.SingletonTwo;

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

        System.out.println("=====================");
        SingletonTwo one1 = SingletonTwo.getInstance();
        SingletonTwo two1 = SingletonTwo.getInstance();
        System.out.println(one1);   //org.example.SingletonTwo@74a14482
        System.out.println(two1);   //org.example.SingletonTwo@74a14482
        System.out.println(one1 == two1);  //true
    }
}
4.1.3 饿汉式 VS 懒汉式

5. 抽象类&抽象方法

java 复制代码 
/**
 * 抽象类： 这个类不允许被实例化了，可以通过向上转型，转向子类实例
 */
public abstract class Animal {
//    public void eat(){
//        System.out.println("动物都需要吃东西");
//    }

    // 抽象方法没有方法体
    // 子类继承父类也必须重写父类的抽象方法，否则也需要将子类定义为抽象类
    // static、final、private   不能与abstract并存
    public abstract void eat();
}

6. 接口

定义接口

java 复制代码 
public interface INet {
    /**
     * 接口中抽象方法可以不写abstract关键字
     *
     * 默认访问修饰符 public
     *
     * ==> 当类实现接口时，需要实现接口中的所有抽象方法，否则需要将该类设置为抽象类
     */
    void network();
    // 接口中可以包含常量， 默认public、 static、 final

    int TEMP = 20;

    // default:默认方法 可以带方法体         jdk1.8后新增的
    // 可以在实现类中重写,并可以通过接口的引用调用
    default void connection(){
        System.out.println("我是接口中的默认链接");
    }

    //静态方法也可以待方法体                 jdk1.8后新增的
    // 不可以在实现类中重写, 可以通过接口名调用
    static void stop(){
        System.out.println("我是接口中的静态方法");
    }
}

实现接口

java 复制代码 
package com.vb.tel;

public class SmartPhoto implements INet{
//    public static final int TEMP = 30;
    public int TEMP = 30;

    public void call(){
        System.out.println("Calling SmartPhoto");
    }

    public void network(){
        System.out.println("Networking SmartPhoto");
    }
    @Override
    public void connection() {
        //调用接口中的默认方法
        INet.super.connection();
        System.out.println("Connection SmartPhoto");
    }
}

测试类

java 复制代码 
public class PhoneTest {
    public static void main(String[] args) {
        FourthPhone phone4 = new FourthPhone();
        phone4.game();            //可以玩游戏
        phone4.getBrand();
        phone4.call();            //手机可以拨打电话
        System.out.println("================");
        IPhoto ip = new FourthPhone();
        ip.photo();                     //拍照
        ip = new Camera();
        ip.photo();                   //相机可以拍照
        System.out.println("================");
        System.out.println(INet.TEMP);   //20
        INet net = new SmartPhoto();
        System.out.println(net.TEMP);    //20
        net.connection();
        //我是接口中的默认链接
        //Connection SmartPhoto
        // 接口中的静态方法需要通过接口名来调用
        INet.stop();               //我是接口中的静态方法
    }
}

7.内部类

7.1 成员内部类

内部类中最常见的，也称为普通内部类

内部类

java 复制代码 
package com.vb.people;

// 外部类
public class Person {
    public int age;

    public void eat(){
        System.out.println("People eat");
    }
    // 获取内部类的方法
    public Heart getHeart(){
        new Heart().temp = 25;
        return new Heart();
    }

    //成员内部类

    /**
     * 1. 内部类在外部使用时,无法直接实例化
     * 选哟借助外部类信息才能完成实例化
     * 2. 内部类可以直接方法外部类的成员;如果出现同名属性,优先访问内部类中定义的
     * 3. 可以通过使用外部类.this.成员的方式,访问外部类中同名的信息
     * 4. 外部类访问内部类的信息,需要通过内部类实例,无法直接方问
     * 5. 内部类编译后.class文件明明: 外部类$内部类.class
     */
    //注: 不加public的话只能在同胞中调用
    public class Heart {
        int age = 13;
        int temp = 22;
        public String beat(){
            eat();
            return Person.this.age+"心脏在跳动";
        }
    }
}

测试类

java 复制代码 
package com.vb.people;

public class PeopleTest {
    public static void main(String[] args) {
        Person vb = new Person();
        vb.age = 25;

        // 同包下访问内部类
//        Heart heart = new Heart();    //不可行
        //获取内部类对象实例:  ==>
        //方式1:  ==> new 外部类.new 内部类
        Person.Heart myHeart = new Person().new Heart();
        System.out.println(myHeart.beat());   //0心脏在跳动

        // 方式2: 通过外部类对象获取内部类实例   ==> 外部类对象.new 内部类
        Person.Heart heart1 = vb.new Heart();
        System.out.println(heart1.beat());    //25心脏在跳动

        // 方式3: 通过外部类对象 获取方法   ==> 外部类对象.获取方法
        heart1 = vb.getHeart();
        System.out.println(heart1.beat());    //25心脏在跳动
        
    }
}
7.2 静态内部类

静态内部类对象可以不依赖于外部类对象，直接创建

java 复制代码 
// 外部类
public class Person {
    public int age;

//    public static void eat(){
    public void eat(){
        System.out.println("People eat");
    }
    // 获取内部类的方法
    public Heart getHeart(){
        new Heart().temp = 25;
        return new Heart();
    }

 //02 静态内部类

    /**
     * 1. 静态内部类中,只能访问外部类的静态成员,如果需要调用非静态成员,可以通过对象实例
     * 2. 创建静态内部类对象实例时,不依赖于外部类对象
     * 3. 可以通过(外部类.内部类.静态成员)的方式,访问内部类中的静态成员
     * 4. 当内部类访问外部类中的静态属性,则可以通过(外部类.属性)的方式;
     *    若需要访问外部类中的静态属性,则可以通过外部类.属性的方式;
     *    若需要访问外部类中的非静态属性,则可以通过 new 外部类().属性  的方式
     */
    public static class Heart {
        public static int age = 13;
        int temp = 22;
        public static void say(){
            System.out.println("say hello");
        }
        public String beat(){
            new Person().eat();
            return new Person().age+"心脏在跳动";
        }
    }
}

测试类

java 复制代码 
public class PeopleTest {
    public static void main(String[] args) {
        Person vb = new Person();

        //获取静态内部类对象实例
        Person.Heart myHeart = new Person.Heart();
        System.out.println(myHeart.beat());
        //People eat
        //0心脏在跳动

        Person.Heart.say();             //say hello
        System.out.println(Person.Heart.age);    //13

    }
}
7.3 方法内部类

方法内部类是定义在外部方法中的内部类，也称局部内部类

注:方法内不能定义静态成员

java 复制代码 
// 外部类
public class Person {
    public int age;

    public void eat(){
        System.out.println("People eat");
    }


    //03 方法内部类
    public Object getHeart(){
        /**
         *  1. 定义在方法内部,作用范围也在方法内
         *  2. 和方法内部成员使用规则一样,class前面不可以添加public等修饰符 & static
         *  3. 类中不能包含静态成员
         *  4. 类中可以包含final\ abstract 修饰的成员
         */
//       abstract class Heart {
        class Heart {
            public final int age = 13;
            int temp = 22;
            public final void say(){
                System.out.println("say hello");
            }

//            public abstract void eat();
            public String beat(){
                new Person().eat();
                return new Person().age+"心脏在跳动";
            }
        }
        return new Heart().beat();
    }

测试

java 复制代码 
public class PeopleTest {
    public static void main(String[] args) {
        Person vb = new Person();
        vb.age = 25;

        //03 方法内部类
        System.out.println(vb.getHeart());
        //People eat
        //0心脏在跳动

    }
}
7.4 匿名内部类

将类的定义与类的创建，放在一起完成

（1）普通方案 & 多态重载方式实现

Person.java

java 复制代码 
package com.vb.anonymous;

public abstract class Person {
    private String name;
    public Person(){

    }

    public String getName() {
        return name;
    }

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

    public abstract void read();
}

Man.java

java 复制代码 
package com.vb.anonymous;

public class Man extends Person{
    @Override
    public void read() {
        System.out.println("Man read");
    }
}

Woman.java

java 复制代码 
package com.vb.anonymous;

public class Woman extends Person {
    @Override
    public void read() {
        System.out.println("Woman read");
    }
}

Test

java 复制代码 
public class PersonTest {
    // 需求: 根据传入不同的人的类型, 调用对应的方法

    // 方案1:
//    public void getRead(Man man){
//        man.read();
//    }
//    public void getRead(Woman woman){
//        woman.read();
//    }

    // 方案 2  多态=>方法的重载
    public void getRead(Person person){
        person.read();
    }

    public static void main(String[] args) {
        PersonTest test = new PersonTest();
        Man man = new Man();
        Woman woman = new Woman();
        test.getRead(man);       //Man read
        test.getRead(woman);     //Woman read
    }
    
}

(2)匿名内部类实现

java 复制代码 
public class PersonTest {
    // 需求: 根据传入不同的人的类型, 调用对应的方法

    public void getRead(Person person){
        person.read();
    }

    public static void main(String[] args) {
        PersonTest test = new PersonTest();

        // 方案3: 匿名内部类
        /**
        * 1. 匿名内部类没有类型名称\ 实例对象名称
         * 2. 编译后的文件命名: 外部类$数字.class
         * 3. 无法使用访问修饰符& static &abstract
         * 4. 无法编写构造方法
         * 5. 无法出现静态成员
         * 6. 可以实现接口,也可以继承父类,但不可兼得

         * 实例对象的同时,完成对于对象内容的编写
         * 适用于: 只用到类的一个实例的场景
         *        在类的定义后马航用到
         *        给类的命名并不会导致代码更容易被理解
         */
        test.getRead(new Person() {

            @Override
            public void read() {
                System.out.println("man read");        //man read
            }
        });

        test.getRead(new Person(){
            @Override
            public void read(){
                System.out.println("woman read");      //woman read
            }
        });
    }
}
相关推荐
漫路在线10 分钟前
JS逆向-某易云音乐下载器
开发语言·javascript·爬虫·python
小辉懂编程39 分钟前
C语言：51单片机实现数码管依次循环显示【1~F】课堂练习
c语言·开发语言·51单片机
tmacfrank41 分钟前
网络编程中的直接内存与零拷贝
java·linux·网络
醍醐三叶2 小时前
C++类与对象--2 对象的初始化和清理
开发语言·c++
weixin_472339462 小时前
Maven 下载安装与配置教程
java·maven
Magnum Lehar3 小时前
3d游戏引擎EngineTest的系统实现3
java·开发语言·游戏引擎
就叫飞六吧3 小时前
Spring Security 集成指南：避免 CORS 跨域问题
java·后端·spring
Mcworld8573 小时前
java集合
java·开发语言·windows
成功人chen某3 小时前
配置VScodePython环境Python was not found；
开发语言·python
天黑请闭眼3 小时前
IDEA：程序编译报错：java: Compilation failed: internal java compiler error
java·intellij-idea
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！05YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU06Coze扣子平台完整体验和实践（附国内和国际版对比）07Ubuntu24.04安装中文输入法08DeepSeek各版本说明与优缺点分析09苍穹外卖面试总结10组基轨迹建模 GBTM的介绍与实现（Stata 或 R）