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

2024-08-27 09:52
文章标签 面向对象编程 高级

本文主要是介绍八、面向对象编程（高级），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 一、类变量与类方法
  • 1.1 类变量快速入门
    • 1.2 什么是类变量
    • 1.3 类变量使用注意事项和细节讨论
    • 1.4 类方法基本介绍
    • 1.5 类方法使用场景
    • 1.6 类方法的注意事项和细节讨论
  • 二、理解main方法 static
  • 三、代码块
    • 3.1 基本介绍
    • 3.2 代码块使用注意事项和细节讨论
  • 四、单例模式
  • 五、final关键字
    • 5.1 final的基本介绍
    • 5.2 final使用注意事项和细节讨论
  • 六、抽象类
    • 6.1 抽象类的引入
    • 6.2 抽象类基本介绍
    • 6.3 抽象类的最佳实践
  • 七、接口
    • 7.1 接口的引入
    • 7.2 接口的基本介绍
    • 7.3 接口的深度讨论
    • 7.4 接口的注意事项和细节
    • 7.5 实现接口 vs 继承类
    • 7.5 接口的多态特性
  • 八、内部类
    • 8.1 内部类基本介绍
    • 8.2 局部内部类
    • 8.3 匿名内部类
      • 8.3.1 匿名内部类的使用注意事项
      • 8.3.2 匿名内部类的最佳实践
    • 8.4 成员内部类
    • 8.5 静态内部类
  • 九、细节
    • 9.1 static变量
    • 9.2 类变量与类方法
    • 9.3 类成员的初始化与实例对象成员的初始化
    • 9.4 接口在JDK 8 后的特性

一、类变量与类方法

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&1class Outer04$1 implements IA {@Overridepublic void call() {System.out.println("老虎叫唤...");}}*/// 7. jdk底层在创建匿名内部类 Outer04$1,立即马上就创建了 Outer04$1 实例，并且把地址// 放回 tiger// 8. 匿名内部类只能使用一次，就不能再使用(指的是该类的实例被加载进堆后，其类信息就被释放掉)IA tiger = new IA() {@Overridepublic void call() {System.out.println("老虎叫唤...");}};tiger.call();// 演示基于类的匿名内部类// 分析// 1. father的编译类型? Father// 2. father的运行类型? Outer04$2// 3. 底层会创建匿名内部类/*class Outer04$2 extends Father {@Overridepublic void test() {System.out.println("匿名内部类重写了test方法");}}*/// 4. 同时也直接返回了 匿名内部类 outer04$2的对象// 5. 注意 ("jack") 参数列表会传递给 构造器Father father = new Father("jack") {@Overridepublic void test() {System.out.println("匿名内部类重写了test方法");}};father.test();// 基于抽象类的匿名内部类Animal animal = new Animal() {@Overridepublic 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); // 1System.out.print(sub.getNum()); // 1Sub s = new Sub();System.out.print(s.n); // 2System.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(){}}

这篇关于八、面向对象编程（高级）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1111335。

相关文章

Apache 高级配置实战之从连接保持到日志分析的完整指南

Apache 高级配置实战之从连接保持到日志分析的完整指南

《Apache高级配置实战之从连接保持到日志分析的完整指南》本文带你从连接保持优化开始,一路走到访问控制和日志管理,最后用AWStats来分析网站数据,对Apache配置日志分析相关知识感兴趣的朋友... 目录Apache 高级配置实战：从连接保持到日志分析的完整指南前言 一、Apache 连接保持 - 性
阅读更多...
mysql中的group by高级用法详解

mysql中的group by高级用法详解

《mysql中的groupby高级用法详解》MySQL中的GROUPBY是数据聚合分析的核心功能,主要用于将结果集按指定列分组,并结合聚合函数进行统计计算,本文给大家介绍mysql中的groupby... 目录一、基本语法与核心功能二、基础用法示例1. 单列分组统计2. 多列组合分组3. 与WHERE结合使
阅读更多...
PyTorch高级特性与性能优化方式

PyTorch高级特性与性能优化方式

《PyTorch高级特性与性能优化方式》：本文主要介绍PyTorch高级特性与性能优化方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录一、自动化机制1.自动微分机制2.动态计算图二、性能优化1.内存管理2.GPU加速3.多GPU训练三、分布式训练1.分布式数据
阅读更多...
Spring Boot集成SLF4j从基础到高级实践(最新推荐)

Spring Boot集成SLF4j从基础到高级实践(最新推荐)

《SpringBoot集成SLF4j从基础到高级实践(最新推荐)》SLF4j(SimpleLoggingFacadeforJava)是一个日志门面（Facade）,不是具体的日志实现,这篇文章主要介... 目录一、日志框架概述与SLF4j简介1.1 为什么需要日志框架1.2 主流日志框架对比1.3 SLF4
阅读更多...
Spring Boot集成Logback终极指南之从基础到高级配置实战指南

Spring Boot集成Logback终极指南之从基础到高级配置实战指南

《SpringBoot集成Logback终极指南之从基础到高级配置实战指南》Logback是一个可靠、通用且快速的Java日志框架,作为Log4j的继承者,由Log4j创始人设计,：本文主要介绍... 目录一、Logback简介与Spring Boot集成基础1.1 Logback是什么？1.2 Sprin
阅读更多...
MySQL复合查询从基础到多表关联与高级技巧全解析

MySQL复合查询从基础到多表关联与高级技巧全解析

《MySQL复合查询从基础到多表关联与高级技巧全解析》本文主要讲解了在MySQL中的复合查询,下面是关于本文章所需要数据的建表语句,感兴趣的朋友跟随小编一起看看吧... 目录前言：1.基本查询回顾：1.1.查询工资高于500或岗位为MANAGER的雇员，同时还要满足他们的姓名首字母为大写的J1.2.按照部门
阅读更多...
Python中Flask模板的使用与高级技巧详解

Python中Flask模板的使用与高级技巧详解

《Python中Flask模板的使用与高级技巧详解》在Web开发中,直接将HTML代码写在Python文件中会导致诸多问题,Flask内置了Jinja2模板引擎,完美解决了这些问题,下面我们就来看看F... 目录一、模板渲染基础1.1 为什么需要模板引擎1.2 第一个模板渲染示例1.3 模板渲染原理二、模板
阅读更多...
Spring Boot 整合 SSE的高级实践(Server-Sent Events)

Spring Boot 整合 SSE的高级实践(Server-Sent Events)

《SpringBoot整合SSE的高级实践(Server-SentEvents)》SSE（Server-SentEvents）是一种基于HTTP协议的单向通信机制,允许服务器向浏览器持续发送实... 目录1、简述2、Spring Boot 中的SSE实现2.1 添加依赖2.2 实现后端接口2.3 配置超时时
阅读更多...
mysql中的group by高级用法

mysql中的group by高级用法

《mysql中的groupby高级用法》MySQL中的GROUPBY是数据聚合分析的核心功能,主要用于将结果集按指定列分组,并结合聚合函数进行统计计算,下面给大家介绍mysql中的groupby用法... 目录一、基本语法与核心功能二、基础用法示例1. 单列分组统计2. 多列组合分组3. 与WHERE结合使
阅读更多...
MySQL高级查询之JOIN、子查询、窗口函数实际案例

MySQL高级查询之JOIN、子查询、窗口函数实际案例

《MySQL高级查询之JOIN、子查询、窗口函数实际案例》：本文主要介绍MySQL高级查询之JOIN、子查询、窗口函数实际案例的相关资料,JOIN用于多表关联查询,子查询用于数据筛选和过滤,窗口函... 目录前言1. JOIN（连接查询）1.1 内连接（INNER JOIN）1.2 左连接（LEFT JOI
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2