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

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。

相关文章

kotlin中的行为组件及高级用法

kotlin中的行为组件及高级用法

《kotlin中的行为组件及高级用法》Jetpack中的四大行为组件：WorkManager、DataBinding、Coroutines和Lifecycle,分别解决了后台任务调度、数据驱动UI、异... 目录WorkManager工作原理最佳实践Data Binding工作原理进阶技巧Coroutine
阅读更多...
深入解析Spring TransactionTemplate 高级用法(示例代码)

深入解析Spring TransactionTemplate 高级用法(示例代码)

《深入解析SpringTransactionTemplate高级用法(示例代码)》TransactionTemplate是Spring框架中一个强大的工具,它允许开发者以编程方式控制事务,通过... 目录1. TransactionTemplate 的核心概念2. 核心接口和类3. TransactionT
阅读更多...
Python中列表的高级索引技巧分享

Python中列表的高级索引技巧分享

《Python中列表的高级索引技巧分享》列表是Python中最常用的数据结构之一,它允许你存储多个元素,并且可以通过索引来访问这些元素,本文将带你深入了解Python列表的高级索引技巧,希望对... 目录1.基本索引2.切片3.负数索引切片4.步长5.多维列表6.列表解析7.切片赋值8.删除元素9.反转列表
阅读更多...
正则表达式高级应用与性能优化记录

正则表达式高级应用与性能优化记录

《正则表达式高级应用与性能优化记录》本文介绍了正则表达式的高级应用和性能优化技巧,包括文本拆分、合并、XML/HTML解析、数据分析、以及性能优化方法,通过这些技巧,可以更高效地利用正则表达式进行复杂... 目录第6章：正则表达式的高级应用6.1 模式匹配与文本处理6.1.1 文本拆分6.1.2 文本合并6
阅读更多...
系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

系统架构师考试学习笔记第三篇——架构设计高级知识（20）通信系统架构设计理论与实践

本章知识考点：         第20课时主要学习通信系统架构设计的理论和工作中的实践。根据新版考试大纲,本课时知识点会涉及案例分析题(25分),而在历年考试中,案例题对该部分内容的考查并不多,虽在综合知识选择题目中经常考查,但分值也不高。本课时内容侧重于对知识点的记忆和理解,按照以往的出题规律,通信系统架构设计基础知识点多来源于教材内的基础网络设备、网络架构和教材外最新时事热点技术。本课时知识
阅读更多...
如何掌握面向对象编程的四大特性、Lambda 表达式及 I/O 流：全面指南

如何掌握面向对象编程的四大特性、Lambda 表达式及 I/O 流：全面指南

这里写目录标题 OOP语言的四大特性lambda输入/输出流（I/O流） OOP语言的四大特性 面向对象编程（OOP）是一种编程范式，它通过使用“对象”来组织代码。OOP 的四大特性是封装、继承、多态和抽象。这些特性帮助程序员更好地管理复杂的代码，使程序更易于理解和维护。 类-》实体的抽象类型 实体（属性，行为） -》 ADT（abstract data type） 属性-》成
阅读更多...
Java基础回顾系列-第七天-高级编程之IO

Java基础回顾系列-第七天-高级编程之IO

Java基础回顾系列-第七天-高级编程之IO 文件操作字节流与字符流OutputStream字节输出流FileOutputStream InputStream字节输入流FileInputStream Writer字符输出流FileWriter Reader字符输入流字节流与字符流的区别转换流InputStreamReaderOutputStreamWriter 文件复制 字符编码内存操作流(
阅读更多...
Java基础回顾系列-第五天-高级编程之API类库

Java基础回顾系列-第五天-高级编程之API类库

Java基础回顾系列-第五天-高级编程之API类库 Java基础类库StringBufferStringBuilderStringCharSequence接口AutoCloseable接口RuntimeSystemCleaner对象克隆 数字操作类Math数学计算类Random随机数生成类BigInteger/BigDecimal大数字操作类 日期操作类DateSimpleDateForma
阅读更多...
Java基础回顾系列-第二天-面向对象编程

Java基础回顾系列-第二天-面向对象编程

面向对象编程 Java类核心开发结构面向对象封装继承多态 抽象类abstract接口interface抽象类与接口的区别深入分析类与对象内存分析 继承extends重写(Override)与重载(Overload)重写(Override)重载(Overload)重写与重载之间的区别总结 this关键字static关键字static变量static方法static代码块 代码块String类特
阅读更多...
Mysql高级篇（中）——索引介绍

Mysql高级篇（中）——索引介绍

Mysql高级篇（中）——索引介绍 一、索引本质二、索引优缺点三、索引分类（1）按数据结构分类（2）按功能分类（3） 按存储引擎分类（4） 按存储方式分类（5） 按使用方式分类 四、 索引基本语法（1）创建索引（2）查看索引（3）删除索引（4）ALTER 关键字创建/删除索引 五、适合创建索引的情况思考题 六、不适合创建索引的情况 一、索引本质 索引本质 是 一种数据结构，它用
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2