八、面向对象编程（高级）

已于 2024-08-27 21:45:26 修改
阅读量1.6k 收藏 20
点赞数 51
分类专栏： Java 文章标签： java
于 2024-08-27 08:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44063529/article/details/141476155
版权

文章目录

一、类变量与类方法

1.1 类变量快速入门

在这里插入图片描述

class Child{
    private String name;
    // 定义一个变量count，是一个类变量（静态变量）static 静态
    // 改变量最大的特点就是会被Child类的所有对象实例访问
    public static int count = 0;

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

    public void join(){
        System.out.print(name + "加入了游戏");
    }
}

在这里插入图片描述

  • 注意：JDK1.8之前，静态变量在方法区中的静态域中；JDK1.8及之后，静态域存储于定义类型的Class对象中，Class对象如同堆中其他对象一样，存在于GC堆中

  • 记住一点：static变量是对象共享的，不管 static 变量在哪里，共识 (1) static 变量被同一个类所有对象共享 (2) static类变量，在类加载的时候就生成了

1.2 什么是类变量

  • 类变量 是随着类的加载而创建的，所以即使没有创建对象实例也可以通过类访问
package com.codeblock;

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

        // AA被加载时，按顺序初始化类变量(n2 --> n1)
        // out:   1. getN1被执行(初始化时的打印)    2. 200(调用类变量的返回)
        
        System.out.println(AA.n2); 
    }
}

class AA{

    public static int n2 = 200;
    public static int n1 = getN1();

    public static int getN1(){
        System.out.println("getN1被执行");
        return 100;
    }

}

在这里插入图片描述

1.3 类变量使用注意事项和细节讨论

在这里插入图片描述

在这里插入图片描述

1.4 类方法基本介绍

在这里插入图片描述

1.5 类方法使用场景

在这里插入图片描述

1.6 类方法的注意事项和细节讨论

在这里插入图片描述

在这里插入图片描述

二、理解main方法 static

在这里插入图片描述

在这里插入图片描述

三、代码块

3.1 基本介绍

  • 代码块 仅用于 加载类 或 创建对象
    在这里插入图片描述

在这里插入图片描述

3.2 代码块使用注意事项和细节讨论

在这里插入图片描述

package com.codeblock;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        AA a = new AA(); // 执行静态代码块的内容
        AA aa = new AA(); // 由于AA类已被加载，则不会执行静态代码块中的内容
    }
}

class AA{
    // 静态代码块
    static{
        System.out.println("AA的静态代码块1");
    }

}

在这里插入图片描述

public class CodeBlickDetail2{
    public static void main(String[] args){
        // 类变量的显示初始化 与 静态代码块中的内容按顺序执行
        // 属性的显示初始化 与 成员代码块中的内容按顺序执行
        A a = new A(); // 1. getN1被执行...   2. 静态代码块被执行...  3. getN2被执行...  4. 普通代码块被执行...
    }
}

class A{
    private int n2 = getN2();
    {
        System.out.println("普通代码块被执行...");
    }

    public static int n1 = getN1();
    static{
        System.out.println("静态代码块被执行...");
    }

    public static int getN1(){
        System.out.println("getN1被执行...");
        return 100;
    }
    
public static int getN2(){
        System.out.println("getN2被执行...");
        return 200;
}

}

在这里插入图片描述

class A{
    public A(){ // 构造器
        // 这里隐藏的执行要求
        // (1) super();
        // (2) 代用普通代码块与属性初始化
        System.out.println("ok");
    }
}

在这里插入图片描述

package com.codeblock;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        new BB();
    }
}

class AA{

    public int aa02 = getAa02();

    {
        System.out.println("AA code block 执行..."); // (6)
    }

    public int getAa02(){
        System.out.println("getAa02执行..."); // (5)
        return 200;
    }

    public static int aa01 = getAa01();
    static {
        System.out.println("AA static code block 执行..."); // (2)
    }

    public static int getAa01() {
        System.out.println("getAa01执行..."); // (1)
        return 1;
    }

    public AA(){
        // 调用Object的构造器（略）
        // 执行 代码块 与 属性初始化
        System.out.println("AA 的构造器"); // (7)
    }

}

class BB extends AA{
    public int bb02 = getBb02();

    {
        System.out.println("BB code block 执行..."); // (9)
    }

    public int getBb02(){
        System.out.println("getBb02执行..."); // (8)
        return 100;
    }

    static {
        System.out.println("BB static code block 执行..."); // (3)
    }

    public static int bb01 = getBb01();

    public static int getBb01() {
        System.out.println("getBb01执行..."); // (4)
        return 10;
    }

    public BB(){
        // 调用AA的构造器
        // 执行 代码块 与 属性初始化
        System.out.println("BB 的构造器"); // (10)
    }

}

四、单例模式

在这里插入图片描述

  • 什么是单例模式
    在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

五、final关键字

5.1 final的基本介绍

在这里插入图片描述

5.2 final使用注意事项和细节讨论

在这里插入图片描述

  • 注意如果对方法的形式参数使用 final ，则在方法内部不能对该形参变量重新赋值；但是，如果是引用类型的形参变量被加了 final,是可以对其属性进行修改的 (本质是该局部变量的值一直都是引用变量的地址)
    在这里插入图片描述

六、抽象类

6.1 抽象类的引入

在这里插入图片描述

abstract class Animal{
    public String name;
    public int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    
    // 这里 eat 实现了，其实也没有什么意义
    // 即：父类方法不确定性的问题
    // ====> 考虑将该方法设计为抽象(abstract)方法
    // ====> 所谓抽象方法就是没有实现的方法
    // ====> 所谓没有实现就是指，没有方法体
    // ====> 当一个类中存在抽象方法时，需要将该类声明为 abstract 类
    // public void eat(){
    //     System.out.println();
    // }
    public abstract void eat();
    
}

在这里插入图片描述

6.2 抽象类基本介绍

在这里插入图片描述

  • 抽象类使用的注意事项和细节讨论
    在这里插入图片描述

在这里插入图片描述

// 对于上述第7点
abstract class E{
    public abstract void hi();
}

// 继承抽象类的，第一种情况：可以不对抽象方法进行实现
abstract class F extends E{
    
}

// 继承抽象类的，第二种情况
abstract class G extends E{
    public abstract void hi(){ // 重写了抽象类的方法

    }
}

在这里插入图片描述

注意：Java中类方法不能被重写，而 抽象方法 存在的意义就是被子类重写

6.3 抽象类的最佳实践

在这里插入图片描述

在这里插入图片描述

七、接口

7.1 接口的引入

在这里插入图片描述

7.2 接口的基本介绍

在这里插入图片描述

package com.interface_;

public class TestInterface {

}

interface Interface{
    // 属性强制是 public static final 修饰,可以不写
    // 方法(除默认方法)强制是 public abstract 修饰,可以不写
    // 默认方法是 public 修饰的

    // 写属性，默认是 public static final 可以省略不写
    public static final String str = "Hello";

    // 写方法
    // 在接口中，抽象方法，可以省略abstract关键字 和 public修饰符
    void hi();

    // 在jdk1.8后,可以有默认实现方法,需要使用 default关键字修饰
    default void ok(){
        System.out.println("ok ....");
    }

    // 在jdk1.8后，可以有静态方法
    static void test1(){

    }

}

7.3 接口的深度讨论

在这里插入图片描述

在这里插入图片描述

7.4 接口的注意事项和细节

在这里插入图片描述

在这里插入图片描述

  • 注：接口之间是继承（支持多继承），类和接口之间是实现。

7.5 实现接口 vs 继承类

在这里插入图片描述

  1. 注：接口是对java单继承的扩展。当子类继承了父类，就自动的拥有父类的功能。如果子类需要扩展功能，可以通过实现接口的方式扩展
  2. 更通俗的理解，继承 主要使子类中拥有父类的方法，侧重于复用性; 接口实现 主要使类中实现接口的抽象方法 侧重于 重写

在这里插入图片描述

7.5 接口的多态特性

在这里插入图片描述

// 接口多态传递现象
public class InterfacePolyPass{
    public static void main(String[] args){
        IG ig = new Teacher(); // 接口引用可以指向
        IH ih = new Teacher(); // 接口多态传递
    }

interface IH{}
interface IG extends IH{} // 继承了 IH 接口
class Teacher implements IG{}
}

八、内部类

8.1 内部类基本介绍

  • 类的五大属性：属性、方法、构造器、代码块、内部类
    在这里插入图片描述

在这里插入图片描述

8.2 局部内部类

  • 在 方法体 或 代码块 中定义的 类 (常见的是在方法体中定义类)
    在这里插入图片描述

在这里插入图片描述

package com.innerclass;

public class InnerTest {
    public static void main(String[] args) {
        Outer o = new Outer();
        System.out.println(o.f1());
    }
}

class Outer {
    private int n1 = 1;

    public int f1() {
        class Inner { // 方法中的局部内部类
            private int n1 = 1; // 与外部类的属性重名
            private int n2 = 2;

            public int getN2() {
                return this.n2;
            }

            public void test() {
                // 需要访问外部类的属性（与内部类中属性重名）
                // Outer.this 的本质就是外部类的对象，即哪个对象调用了f1,  Outer.this 就是哪个对象
                System.out.println(Outer.this.n1);
            }
        }
        Inner inner = new Inner();
        inner.test();
        return inner.getN2();
    }

}

8.3 匿名内部类

在这里插入图片描述

package com.innerclass;

public class InnerAnonyClass {
    public static void main(String[] args) {
        Outer04 o = new Outer04();
        o.method();
    }
}

class Outer04 { // 外部类
    private int n1 = 10;

    public void method() {
        // 基于接口的匿名内部类
        // 解读
        // 1. 需求：想使用IA接口，并创建对象
        // 2. 传统方式，是写一个类，实现该接口，并创建对象
        // 3. 老韩需求是 Tiger 类只是使用一次,后面再不使用
        // 4. 可以使用匿名内部类来简化开发
        // 5. tiger 的编译类型? IA
        // 6. tiger 的运行类型? 就是匿名内部类  Outer04$1
        /*
        底层 会分配 类名 Outer04&1
        class Outer04$1 implements IA {
            @Override
            public void call() {
                System.out.println("老虎叫唤...");
            }
        }
         */
        // 7. jdk底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址
        // 放回 tiger
        // 8. 匿名内部类只能使用一次，就不能再使用(指的是该类的实例被加载进堆后，其类信息就被释放掉)
        IA tiger = new IA() {
            @Override
            public void call() {
                System.out.println("老虎叫唤...");
            }
        };
        tiger.call();

        // 演示基于类的匿名内部类
        // 分析
        // 1. father的编译类型? Father
        // 2. father的运行类型? Outer04$2
        // 3. 底层会创建匿名内部类
        /*
        class Outer04$2 extends Father {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        }
         */
        // 4. 同时也直接返回了 匿名内部类 outer04$2的对象
        // 5. 注意 ("jack") 参数列表会传递给 构造器
        Father father = new Father("jack") {
            @Override
            public void test() {
                System.out.println("匿名内部类重写了test方法");
            }
        };
        father.test();

        // 基于抽象类的匿名内部类
        Animal animal = new Animal() {
            @Override
            public void eat() {
                System.out.println("小狗吃骨头...");
            }
        };

        animal.eat();

    }
}

interface IA {
    void call();

}

class Father {
    private String name;

    public Father() {
    }

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

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

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

    public String getName() {
        return name;
    }
}

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

8.3.1 匿名内部类的使用注意事项

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

8.3.2 匿名内部类的最佳实践

在这里插入图片描述

8.4 成员内部类

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

8.5 静态内部类

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

九、细节

9.1 static变量

  • 注意：JDK1.8之前，静态变量在方法区中的静态域中；JDK1.8及之后，静态域存储于定义类型的Class对象中，Class对象如同堆中其他对象一样，存在于GC堆中

  • 记住一点：static变量是对象共享的，不管 static 变量在哪里，共识 (1) static 变量被同一个类所有对象共享 (2) static类变量，在类加载的时候就生成了

9.2 类变量与类方法

  • 子类是不继承父类的static变量和方法的。因为这是属于类本身的。但是子类是可以访问的。
  • 子类和父类中同名的static变量和方法都是相互独立的,并不存在任何的重写的关系。
  • 在多态的情况下调用 类变量 与 类方法 均看均由 编译类型
  • 类方法可以在同一类重载

public class Test{
    public static void main(String args){
        Base sub = new Sub();
        System.out.print(sub.n); // 1
        System.out.print(sub.getNum()); // 1
        
        Sub s = new Sub();
        System.out.print(s.n); // 2
        System.out.print(s.getNum()); // 2
        
    }

}

class Base{
    public static int n = 1;
    
    public static int getNum(){
        return 1;
    }
}

class Sub{
    public static int n = 2;
    
    public static int getNum(){
        return 2;
    }
    
}

9.3 类成员的初始化与实例对象成员的初始化

  • 类成员：类变量、类方法
    • 类变量：
      1. 可以显示赋值 public static String str = "1"
      2. 在 static 代码块 中
    • 类方法：在随类的加载而被加载进方法区
  • 实例对象成员：属性和方法
    • 属性：
      1. 可以显示赋值
      2. 在代码块中
      3. 在构造器中

9.4 接口在JDK 8 后的特性

在这里插入图片描述

package com.interface_;

public class TestInterface {

}

interface Interface{
    // 属性强制是 public static final 修饰,可以不写
    // 方法(除默认方法)强制是 public abstract 修饰,可以不写
    // 默认方法是 public 修饰的

    // 写属性，默认是 public static final 可以省略不写
    public static final String str = "Hello";

    // 写方法
    // 在接口中，抽象方法，可以省略abstract关键字 和 public修饰符
    void hi();

    // 在jdk1.8后,可以有默认实现方法,需要使用 default关键字修饰
    default void ok(){
        System.out.println("ok ....");
    }

    // 在jdk1.8后，可以有静态方法
    static void test1(){

    }

}
ModelBulider
关注
专栏目录
C++面向对象高级编程
qq_44807796的博客
11-10 2369
C++面向对象高级编程 概览 #ifndef COMPLEX_H_ #define COMPLEX_H_ class complex{ private: double re, im; public: complex (double r = 0, double i = 0) : re (r), im (i) {} // 构造函数 complex& operator += (const complex&); // 函数声明 double real () const {retur
java面向对象编程总结
weixin_64926930的博客
04-29 1509
在经过十周的java学习后，我对于原本一窍不通的课程又有了新的理解，它也并不是原本我不认识之前高冷的模样，我在慢慢的接触它，认识它，了解它。但现在为止，我对于我所学习的java中的“面向对象编程”做一个个人总结，其中观点仅代表个人，如有错误，敬请纠正。 在我所学习的教材中，将“面向对象编程”分为1,2,3三个章节，我也将我所学习的内容分为三个点来进行总结。 面向对象编程1 什么是面向对象 在这个章节里面，我们知道了什么是面向对象，如果用一个比喻来说的话，面向对象就像是养花一样，买个花瓶，再买束鲜花，不喜
Python 面向对象编程详解
CSDN
08-04 6587
面向对象,OOP英文全称(Object-Oriented Programming)是一种高效的编程思路,面向对象技术已经成为当今软件设计和开发领域的主流技术,面向对象编程是一种编程方式,使用 "类" 和 "对象" 来实现,所以面向对象编程其实就是对 "类" 和 "对象" 的使用,类就是一个模板,模板里可以包含多个方法(函数),方法里实现各种各样的功能,对象则是根据模板创建的实例,通过实例对象可以执行类中的方法,每个对象都拥有相同的方法,但各自的数据可能不同.
为什么要面向对象编程？
weixin_38087692的博客
06-21 1616
问题的由来，要从一块烤肉说起。6月一天晚上，小李摸了摸肚子，想趁着这温度刚好的夜晚，带着一天学习的充实感，去开心地吃烤肉串喝点啤酒。可是最近购物太多，花的太多，资金也不那么充裕，觉得晚上不应该再去加这餐。可这转念一想，饭得痛快地吃啊，用什么法子吃到呢？那不就得去赚钱，小李学的是计算机，那计算机不得学到技术才可以赚钱吃肉肉嘛。于是乎，小李痛定思痛并左右查资料，想得到学习经验和方法，更快地学好，为将来吃肉肉做准备。 以上是瞎写的小随笔，干杯~哈哈 数据结构和算法是必中必学。读到面向编程这一章的时候，里面出来和很
C#面向对象高级编程语言
m0_72572822的博客
10-01 1638
C#
7.0 Python 面向对象编程
热门推荐
CSDN
08-14 1万+
python是一种面向对象的编程语言，面向对象编程（Object-Oriented Programming，OOP）是一种编程思想，其核心概念是“对象”。对象是指一个具有特定属性和行为的实体，而面向对象编程就是通过对这些实体进行抽象、分类、封装和继承等操作，来实现程序的结构和逻辑。在python中，我们可以通过定义类、创建实例和调用方法等方式，来实现面向对象编程的思想，从而编写出更加灵活、可扩展、易维护的程序。
JavaScript高级教程（面向对象编程）
一只努力搬砖的打工妹纸
01-25 5322
面向对象编程 有两大编程思想：面向过程和面向对象； 面向过程编程POP(Process-oriented programming) 面向过程即分析出解决问题所需要的步骤，然后用函数将这些步骤一步步实现，使用的时候再一个个的一次调用就可以了； 即将大象装进冰箱，从面向过程来看，需要打开冰箱门、装进去大象、关上冰箱门 面向对象编程OOP(Object Oriented Programming) 面向对象即把事务分解成为一个个对象，然后由对象之间分工与合作；是以对象功能来划分问题，而不是步骤；在面向对
JavaScript 面向对象编程
gako15587481707的博客
06-18 1335
面向对象编程是一种程序设计思想，它具有 3 个显著的特征：封装、继承、多态。
c语言如何实现面向对象编程
qq_27726651的博客
12-01 4641
一、简介 C语言是面向过程的一门语言，C++是面向对象，这个特性早已深入人心。但是嵌入式底层以及大型操作系统等却都是用C开发的。如果只用面向过程去开发这类大型软件，肯定行不通。 因此，C语言也可以用面向对象的思维去开发。例如现在的STM32的HAL库就在向着这个趋势进发。 二、 C语言实现封装 大部分使用 C 语言进行开发的工程师，在接触更高级的编程语言之前...
面向过程编程和面向对象编程的区别
qq_42016346的博客
06-06 3322
面向过程编程和面向对象编程是两种不同的编程范式，它们在代码的组织和结构上有所不同。
Labview面向对象编程
10-31
Labview面向对象编程是NI（National Instruments）的图形化编程环境Labview中的一种高级编程技巧，它借鉴了传统编程语言中的面向对象概念，如封装、继承和多态性，为Labview开发带来了更高的代码复用性和可维护性。...
第16章 LabVIEW中的面向对象编程,labview面向对象的框架,LabView
09-11
总之，LabVIEW的面向对象编程提供了更高级的编程模型，使得开发者能够构造复杂、模块化的系统。熟练掌握这些概念和技巧，将有助于提升LabVIEW项目的效率和质量。在实际工作中，结合良好的编程实践，如代码注释、模块...
东北大学面向对象编程高级编程实验教程
10-26
东北大学面向对象编程高级编程实验教程 本课程实验报告主要介绍了使用 JSP 和 Servlet 技术开发图书馆管理系统的设计和实现。该系统具有登录、注册、图书的添加、修改、删除、个人信息查询、修改、退出等功能。 ...
PLC的面向对象编程
07-26
PLC（可编程逻辑控制器）面向对象编程是一种先进的编程模式，它借鉴了计算机高级语言中面向对象编程（OOP）的概念，并将其应用于工业控制系统中。尽管在PLC编程中无法完全实现面向对象语言的所有特点，比如“继承”...
面向对象的高级编程(共32张PPT)精选.pptx
11-16
在面向对象编程中，封装是基础，它通过隐藏内部细节，使调用者只需关注对象的公共接口。继承则进一步扩展了封装的概念，允许创建新的类（扩充类）基于现有类（基类）进行构建，从而减少了代码重复，提高了代码复用性...
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 707
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 664
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 478
spring boot 整合 mybatis
Java内存布局
最新发布
阿呆的专栏
10-01 761
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
JavaScript面向对象与高级编程技术
总结，JavaScript的全集涵盖了从基础语法到高级特性的广泛知识，包括但不限于变量、数据类型、运算符、控制流、函数、对象、数组、正则表达式、错误处理以及面向对象编程。学习并掌握这些知识点，将有助于开发者构建...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ModelBulider

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值