Java on 映屿

Java面向对象编程——多态、抽象类、接口

i@glowisle.me (五葉地錦) — Fri, 10 Jan 2025 15:05:00 +0000

什么是多态

在继承/实现情况下的一种现象，表现为：对象多态、行为多态。

多态的前提

有继承/实现关系；存在父类引用子类对象；存在方法重写
多态的注意事项
多态是对象、行为的多态，成员变量不体现多态。

使用多态的好处

在多态形式下，右边的对象是解耦合的，更便于拓展和维护。
定义方法时，使用父类类型的形参，可以接收一切子类对象，扩展性更强、更便利。

多态下产生的一个问题

多态下不能使用子类的独有功能。

多态下的类型转换

自动类型转换：父类变量名 = new 子类();
强制类型转换： 子类变量名 = (子类)父类变量

强制类型转换的注意事项

存在继承/实现关系就可以在编译阶段进行强制类型转换，编译阶段不会报错。
运行时，如果发现对象的真实类型与强转后的类型不同，就会报类型转换异常(ClassCastException)

强转前，Java建议：

使用instanceof关键字，判断当前对象的真是类型，再进行强制类型转换。

final

final关键字的中文是最终的意思，可以修饰类、方法、变量
- 修饰类：该类被称为最终类，特点是不能被继承了。
- 修饰方法：该方法被称为最终方法，特点是不能被重写了。
- 修饰变量：该变量只能被赋值一次。

常量

使用了static final 修饰的成员变量就被称为常量；
作用：通常用于记录系统的配置信息。
注意：常量的命名规范：使用大写英文单词，多个单词使用下划线连接起来。

视同常量记录系统配置信息的优势、执行原理

代码可读性更好、可维护性也更好。
程序编译后，常量会被宏替换：出现常量的地方全部会被替换成其记住的字面量，这样可以保证使用常量和直接用字面量的性能是一样的。

抽象类

什么是抽象类

Java中有个关键字叫abstract，他就是抽象的意思，可以用来修饰类、成员方法
abstract修饰类，这个就是抽象类，修饰成员方法同理。

抽象类的注意事项、特点

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
类该有的成员（成员变量、方法、构造器）抽象类都可以有。
抽象类最主要的特点： 抽象类不能创建对象，仅作为一种特殊的父类，让子类继承并实现。
一个类继承抽象类，必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

抽象类的使用场景和好处

父类知道每个子类都要做某个行为，但每个子类做的情况不一样，父类就定义成抽象方法，交给子类去重写实现，我们设计这样的抽象类，就是为了更好的支持多态。~~爸爸画饼儿子烙饼~~

接口

接口概述

Java提供了一个关键字interface，用这个关键字我们可以定义出一个特殊的结构：接口。
注意：接口不能创建对象；接口是用来被类实现（implements）的，实现接口的类被称为实现类。
一个类可以实现多个接口，实现类实现多个接口必须重写完全部接口的全部抽象方法，否则实现类需要定义成抽象类。

Java面向对象编程——继承

i@glowisle.me (五葉地錦) — Fri, 10 Jan 2025 13:19:11 +0000

什么是继承

Java中提供了一个关键字extends，用这个关键字，可以让一个类和另一个类建立起父子关系。

继承的特点

子类能继承父类的非私有成员变量和成员方法。

继承后对象的创建

子类的对象是由子类、父类共同完成的。

继承相关的注意事项

权限修饰符

什么是权限修饰符？

用来限制类中的成员（成员变量、成员方法、构造器、代码块…）能够被访问的范围

权限修饰符有几种与各自的作用

修饰符	在本类中	同一个包下的其他类	任意包下的子类	任意包下的任意类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√
provate < 缺省 < protected < public

单继承

Java是继承的，Java中的类不支持多继承，但是支持多层继承。

Object类

Ojbect类是所有Java类的父类，任何类都是Object的子类。

方法重写

什么是方法重写

当子类发现父类中的方法无法满足自己的需求时，子类可以重写一个方法名称、参数列表一样的方法去覆盖父类的这个方法，这就是方法重写。
注意：方法重写后，方法的访问遵循就近原则。

方法重写的注意事项

重写时使用Override注解，他可以指定Java编译器，检查我们方法重写的格式是否正确，代码可读性也会更好。
子类重写父类方法时，访问权限必须大于或等于父类该方法的权限（public > protected > 缺省）。
重写的方法返回值类型，必须与被重写方法的返回值类型一样，或者范围更小。
私有方法、静态方法不能被重写，如果重写会报错。

方法重写在开发中的常见应用场景

子类重写Object类的toString()方法，以便返回对象的内容。

子类中访问其他成员的特点

在子类方法中访问其他成员是按照就近原则的。
- 先子类局部范围找。
- 然后子类成员范围找。
- 然后父类成员找
- 然后父类成员范围找，如果父类范围还没有找到则报错。
如果子父类中，出现了重名的成员，会优先使用子类的，如果此时一定要在子类中使用父类的方法怎么办？
- 可以通过super关键字，指定访问父类的成员：super.父类成员变量/父类成员方法

子类构造器的特点

子类的全部构造器，都会先调用父类的构造器，再执行自己。

子类构造器是如何实现调用父类构造器的：

默认情况下，子类全部构造器的第一行代码是super();（写不写都有），他会调用父类的无参数构造器。
如果父类没有无参数构造器，我们必须在子类构造器的第一行手写super();，指定去调用父类的构造器。

修复Geyser下基岩版玩家无法在地狱基岩层放置方块

i@glowisle.me (五葉地錦) — Wed, 08 Jan 2025 17:26:00 +0000

在plugins\Geyser-Spigot\config.yml中把第160行的above-bedrock-nether-building: false改为true，重启服务器，问题解决~ 原理：geyser把下界翻译成了末地，会导致下界天空变成末地的样式，不过可以解决基岩版玩家在地狱基岩层的问题。

Spigot服务端控制台中文乱码解决方案

i@glowisle.me (五葉地錦) — Sat, 04 Jan 2025 08:35:00 +0000

把-Dfile.encoding=UTF-8加在开服脚本文件的-jar前即可。
在启动脚本第一行加上chcp 65001 我的启动脚本如下：

chcp 65001
java -Dfile.encoding=UTF-8 -jar spigot-1.21.jar

String的注意事项

i@glowisle.me (五葉地錦) — Thu, 19 Dec 2024 22:28:15 +0000

String的注意事项

1. String对象的内容不可改变，被称为不可变字符串对象。
1. 只要是以“…”的方式写出的字符串，都会存储到字符串常量池，且相同的字符串只存储一份；
但通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中。

不可变字符串对象

不可变？它肯定可变啊，比如

package string;  
  
public class StringDemo3 {  
    public static void main(String[] args) {  
        String name = "yingyu5658";  
        name += ".me";  
        name += "域名";  
        System.out.println(name);  
  
    }  
}

这时候把name打印出来不就是yingyu5658.me域名了吗？每次试图改变字符串对象实际上是新产生可字符串对象，变量每次都与指向了新的字符串对象，之前字符串对象的内容确实是没有改变的，因此说String的对象都是不可变的。

第二点注意事项

示例代码：

package string;  
  
public class StringDemo3 {  
    public static void main(String[] args) {  
        String s1 = "abc";  
        String s2 = "abc";  
        System.out.println(s1 == s2);  
        //true  
    }  
}

这里使用双等来判断两个变量的地址是否相同，返回结果为true,也就是说，地址是相同的。原理：上文提到，双引号包裹住的字符串，会被保存到字符串常量池中，且相同的字符串只存储一份。这里我们声明了两个内容为abc的String类型变量。Java是很聪明的，当我们把s2声明，它要存到字符串常量池时，看到内容一样，就不再存了，而是把s2也指向abc，因此s1地址和s2地址是一样的。

new

示例代码：

package string;  
  
public class StringDemo3 {  
    public static void main(String[] args) {  
        char[] chars = {'a','b','c'};  
       String a1 =  new String(chars);  
       String a2 =  new String(chars);  
        System.out.println(a1 == a2);  
        //false  
    }  
}

上文提到，每new一次就会创建一个新的对象，所以此时再比较两者地址，返回false，是不同的。

面向对象编程总结

i@glowisle.me (五葉地錦) — Wed, 18 Dec 2024 16:30:00 +0000

面向对象（oop）

面向对象编程的思想：面向。拿或者找。

对象：东西面向对象编程：拿东西过来编程面向对象：把现实世界中的食物看成一个一个对象来解决问题的。（万物皆对象）面向对象的好处：代码更符合人类的思维习惯。编程更简单。看程序更容易理解（？）

类、对象：

类（设计图）：相同事物，共同特征的描述。对象：对象是类的具体的实例。对象 = 实例在Java中必须先定义类，才能得到对象

定义类来创建对象使用

定义类的格式

成员变量（代表属性，一般是名词）：数据类型名称;
成员方法（代表行为，一般是动词）
构造器（前面的区域以后再来探索吧）
代码块（前面的区域以后再来探索吧）
内部类（前面的区域以后再来探索吧）

类中具体怎么写：

一般名词定义成成员变量（属性） 修饰符数据类型变量名称 = 初始值 成员变量不建议给初始值，它存在默认值。

一般动词定义成方法（行为）

创建对象

类名对象名 = new 构造器();

对象使用：

对象名.成员变量 对象名.成员方法

构造器

	作用：
		初始化一个累的对象并且返回这个类的地址。
		详细格式：修饰符 类名(形参){...}
		构造器的分类：
					无参数构造器：初始化一个类的对象，里面的数据都是默认值，并返回地址。
					有参数构造器：初始化一个类的对象，并返回地址，并且可以同时为对象赋值。
		构造器如何调用：
					类名 对象 = new 构造器;
		注意：任何类写出来，自带无参数构造器
			   但是在这个类中定义了一个有参数构造器了，那么无参数构造器就消失了，此时如果还要使用无参数构造器，必须自己写一个。

this关键字

作用：代表了当前对象的地址。可以访问当前对象的成员变量信息和成员方法

具体应用场景

可以用在有参数构造器中可以用在方法中

封装

面向对象三大特征：封装、继承、多态。封装的基本思想：决定属性和行为归属谁的问题。

如何更好的封装：

成员变量私有化，只能在本类访问。

合理暴露

提供成套的getter和setter方法暴露取值赋值。

标准JavaBean

JavaBean是什么：是实体类。作用：创建对象，封装数据。

Java面向对象编程快速入门

i@glowisle.me (五葉地錦) — Sun, 01 Dec 2024 13:05:00 +0000

什么是面向对象编程

通俗易懂的说，就是把一坨一坨的数据放到一起存储比如要存储一个学生的语文成绩和数学成绩新建一个类

public class Student {
    String name;//名字
    double chinese;//语文成绩
    double math;//数学成绩

    public void printTotalScore() {
        System.out.println(name + "的总成绩是" + (chinese + math));
    }

    public void printAverageScore() {
        System.out.println(name + "的平均成绩是" + (chinese + math) / 2.0);
    }
}

这样学生的模板就创建好了，但是这个模板还没有指向学生的每一个个体。我们可以再同一个包下再新建一个类。

public class Test {
    public static void main(String[] args) {
        //1.创建宇哥学生对象来封装学生a的数据
        Student s1 = new Student();
        s1.name = "学生a";
        s1.chinese = 100;
        s1.math = 100;
        s1.printTotalScore();
        s1.printAverageScore();

        //2.再创建一个学生对象，封装学生b的数据
        Student s2 = new Student();
        s2.name = "学生b";
        s2.chinese = 100;
        s2.math = 59;
        s2.printTotalScore();
        s2.printAverageScore();
    }
}

用以上代码新建一个学生类并且调用我们之前写好的功能

开发一个一个的对象，把数据交给对象，再用调用对象的方法来完成对数据的处理，这种方法叫面向对象编程。

深刻认识面向对象

i@glowisle.me (五葉地錦) — Sun, 01 Dec 2024 13:31:00 +0800

面向对象编程的好处

按照詹姆斯·高斯林的看法，世间万物都是对象。好比要出去旅游，你要找到车这个对象调用他的行驶功能使用来带你出去旅游。

所以面向对象编程的好处就是：符合人类思维习惯，编程更简单，更直观。

程序中的对象到底是什么

对象本质上是一种特殊的数据结构，很像数据库，但是数据库是持久存储的数据。体现出计算机各个学科的交叉。一开始设计的类就是一张表，后续在其他类中填入这张表的内容。

对象是怎么出来的

class也就是类，也称为对象的设计图（或者对象的模板）

类里可以设计很多变量，用来说明对象可以处理什么数据。
类里还可以设计很多的方法，描述对象有什么功能，也就是要对数据进行什么样的处理。接下来我们就可以在程序中new对象了 也就是先用class设计对象，然后再用class new出对象。

具体使用语法见上一篇文章[post cid=“98” /]

Java方法的传参原理

i@glowisle.me (五葉地錦) — Sat, 30 Nov 2024 20:14:00 +0000

Java方法的参数传递机制-基本类型

值传递

值传递是什么

在传输实参给方法的形参的时候，传输的是实参变量中存储的副本 说人话，把实参里面的东西赋值了一部分扔了给形参

值传递具体理解案例

public class prameter {
    public static void main(String[] args) {
        int a = 10; //定义一个int变量a赋值为10
        change(a); //调用change方法
        System.out.println("main" + a); //打印mian a中的值
    }

//这里开始写方法
    public static void change(int a){
        System.out.println("change1" + a); //打印方法中a的值
        a = 20;
        System.out.println("change2"a); //打印赋值后a的值
    }
}

我们运行以后，控制台输出的结果为

change1 10
change2 20
main 10

为什么main中打印的不是赋值后的20？

这就要提到刚才的概念：值传递 我们定义了一个变量a = 10；,在方法中public static void change(int a) 由于值传递，也就是把值复制了一分传给方法，所以我们方法里用的值永远都是刚刚定义的int a = 10;，所以change(a); = change(10); 我们后面再赋值，打印出来的结果还是10，除非你把变量定义的代码改了，否则方法里的值不会变。

引用类型的参数传递

引用类型的参数传递也满足值传递，但代码中会有不同的地方。示例代码

    public static void main(String[] args) {
        int[] arrs = new int[]{10,20,30};
        change(arrs);
        System.out.println("main" + arrs[1]);
    }
    public static void change(int[] arrs) {
        System.out.println("方法内1" + arrs[1]);
        arrs[1] = 222;
        System.out.println("方法内2" + arrs[1]);
    }

结果：

方法内1：20
方法内2：222
main：222

上一篇文章提到了栈内存的执行顺序，根据上一篇所讲，代码执行顺序如下: 1.先执行

    public static void change(int[] arrs) {
        System.out.println("方法内1" + arrs[1]);
        arrs[1] = 222;
        System.out.println("方法内2" + arrs[1]);
    }

2.再回到main方法

        System.out.println("main" + arrs[1]);

在1时进行打印，结果得到数组内第二个位置存储的20. 代码继续向下执行，第二个位置被赋值为222，此时再打印它，结果得到222. 这时候change方法执行完，它在栈内存中会被清除，然后回到main方法，由于刚才change方法中对arr[1]进行了赋值，所以我们再打印，结果得到的还是它赋值出来的222.

Java方法的基本使用

i@glowisle.me (五葉地錦) — Fri, 29 Nov 2024 20:45:20 +0800

方法是什么

方法是一种语法结构，它可以把代码封装成一段功能，以便重复调用。

方法的完整格式：

例子：数字求和

    public static  int sum(int a,int b){
        int c = a + b;
        return c;
    }

方法的调用：

       int rs= sum(10,20);

方法使用的注意点：

方法申明了具体的返回值类型，内部必须使用return返回对应类型的数据。

形参列表可以有多个，甚至可没有；如果有多个形参，必须用英文逗号隔开，且不能给初始化值

使用方法的好处

提高代码的复用性，提高了开发效率
让程序逻辑性更清晰

方法的其他定义形式

    public static void printHelloWorld(int n) {
        for (int i = 1; i <=n; i++) {
            System.out.println("Hello World");
        }
    }
//打印三行helloworld（使用方法）

如果方法不需要返回数据，返回类型必须申明成void此时方法内部可以不使用return返回数据。
方法如果不需要接收数据，则不需要定义形参，调用方法时也不可以传数据给方法了。
没有参数，且没有返回类型（void）申明的方法，称为无参数、无返回值的方法

Java on 映屿

Java面向对象编程——多态、抽象类、接口

什么是多态

多态的前提

多态的注意事项

使用多态的好处

多态下产生的一个问题

多态下的类型转换

强制类型转换的注意事项

强转前，Java建议：

final

常量

视同常量记录系统配置信息的优势、执行原理

抽象类

什么是抽象类

抽象类的注意事项、特点

抽象类的使用场景和好处

接口

接口概述

Java面向对象编程——继承

什么是继承

继承的特点

继承后对象的创建

继承相关的注意事项

权限修饰符

什么是权限修饰符？

权限修饰符有几种与各自的作用

单继承

Object类

方法重写

什么是方法重写

方法重写的注意事项

方法重写在开发中的常见应用场景

子类中访问其他成员的特点

子类构造器的特点

子类构造器是如何实现调用父类构造器的：

修复Geyser下基岩版玩家无法在地狱基岩层放置方块

Spigot服务端控制台中文乱码解决方案

String的注意事项

String的注意事项

不可变字符串对象

第二点注意事项

new

面向对象编程总结

面向对象编程的思想：面向。拿或者找。

类、对象：

定义类来创建对象使用

定义类的格式

类中具体怎么写：

一般动词定义成方法（行为）

创建对象

对象使用：

构造器

this关键字

具体应用场景

封装

如何更好的封装：

合理暴露

标准JavaBean

Java面向对象编程快速入门

什么是面向对象编程

深刻认识面向对象

程序中的对象到底是什么

对象是怎么出来的

Java方法的传参原理

Java方法的参数传递机制-基本类型

值传递是什么

值传递具体理解案例

为什么main中打印的不是赋值后的20？

引用类型的参数传递

Java方法的基本使用

方法是什么

方法使用的注意点：

使用方法的好处

方法的其他定义形式