站在C/C++的肩膀速通Java面向对象
默认学过C或C++，对变量、表达式、选择、循环都会。
运行特征
- 解释型语言（JavaScript、Python等）
源文件-(平台专属解释器)->解释器中执行 - 编译型语言（C++、Go等）
源文件-(平台编译器)->平台可执行文件 - Java
源文件-(通用编译器)->.class二进制文件-(平台JVM)->JVM中执行
Java名词解释
- JVM（Java Virtual Machine）虚拟机
- JRE（Java Runtime Environment）运行环境（包含JVM和解释器），有这个就能运行Java程序
- JDK（Java Development Kit）包含JRE和相关工具的Java开发环境
常用Dos命令
dir查目录，不是ls
cd进目录
d:进D盘
mkdir创建文件夹
rd删除文件夹
cls清屏
exit退出
Java的相关文件（Windows平台）
.java文件：Java源代码文件，包含了程序员编写的Java代码。.class文件：Java字节码文件，是由Java编译器编译生成的中间代码文件，可以由Java虚拟机（JVM）执行。.jar文件：JavaArchive文件，是一种归档文件格式，用于将多个Java类文件、资源文件和元数据打包成一个文件。通常用于分发和部署Java应用程序、库或组件。java.exe：Java程序的执行器，用于执行已编译成的Java字节码文件（.class文件）。javac.exe：Java编译器，用于编译Java源代码文件（.java文件）成为Java字节码文件（.class文件）。jar.exe：Java归档工具，用于创建和管理Java归档文件（.jar文件），可以将多个.class文件打包成一个可执行的JAR文件。javadoc.exe：Java文档生成工具，用于根据源代码中的注释生成API文档，将Java代码注释转换为HTML格式的文档。jdb.exe：Java调试器，用于在调试Java程序时启动Java调试器，允许暂停程序、检查变量值、设置断点等操作。javap.exe：Java反汇编器，用于反编译Java字节码文件（.class文件）成为Java源代码的形式，可以查看.class文件的内容，了解其中包含的类、方法、字段等信息。
一个Java程序开发通常如下：编写.java源文件，使用javac.exe编译成.class文件，使用java.exe执行.class文件（不能带.class后缀，直接java 类名）。
基本数据类型
- 整型（Integer Types）：
- byte：8位，有符号，范围为 -128 到 127。
- short：16位，有符号，范围为 -32,768 到 32,767。
- int：32位，有符号，范围为 -2^31 到 2^31 - 1。
- long：64位，有符号，范围为 -2^63 到 2^63 - 1。
123L
- 浮点型（Floating-Point Types）：
- float：32位，单精度浮点数，范围为大约 1.4e-45 到 3.4e+38，精确度为约 7 位小数。
12.2f - double：64位，双精度浮点数，范围为大约 4.9e-324 到 1.8e+308，精确度为约 15 位小数。
- float：32位，单精度浮点数，范围为大约 1.4e-45 到 3.4e+38，精确度为约 7 位小数。
- 字符型（Character Type）：
- char：16位，Unicode字符，范围为 ‘\u0000’（即 0）到 ‘\uffff’（即 65,535）。
- 布尔型（Boolean Type）：
- boolean：表示 true 或 false 值。
易错：
引用数据类型
- 类（Class）：类是用户定义的数据类型，用于创建对象。类包含属性（字段）和方法，可以通过实例化（创建对象）来访问它们。
- 接口（Interface）：接口是一种抽象数据类型，用于定义类应该实现的方法。类可以实现一个或多个接口，以达到实现多态性和代码复用的目的。
- 数组（Array）：数组是一组相同类型的数据元素的集合。数组在内存中是连续存储的，可以通过索引访问其中的元素。
- 枚举（Enum）：枚举是一种特殊的类，用于定义一组命名的常量。枚举常量通常用于表示有限的一组可能值，如星期几、月份等。
- 字符串（String）：字符串是Java中的特殊对象，用于表示文本数据。字符串是不可变的，可以进行各种操作，如连接、截取、替换等。
- 包装类（Wrapper Classes）：包装类是一种将基本数据类型封装为对象的类。Java提供了一组包装类，如Integer、Double、Boolean等，用于在需要对象的上下文中使用基本数据类型。
- 自定义引用数据类型：除了以上提到的内置引用数据类型外，开发人员还可以创建自定义的引用数据类型，通过定义类和接口来实现自己的数据结构和算法。
控制台输入
import java.util.Scanner;
class UseScanner {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("Input your name: ");
String name = input.next(); // 取字符串
System.out.println("OK~ next... input your age: ");
int age = input.nextInt(); // 取整数
System.out.println("Hello " + name + ". And your age is " + age + ". Choose A or B please.");
char a = input.next().charAt(0); // 取字符串第0个字
System.out.println("You choose " + a);
input.close();
}
}
Java特别注意
- switch语句中允许接受
byte、short、int、char、String作为变量，但不支持long
数组
class UseArray {
public static void main(String[] args) {
int[] arr; // 声明数组
arr = new int[5]; // 分配空间
int[] arr2 = { 1, 2, 3, 4, 5 }; // 声明，并（包含分配空间）赋值
printArray(arr);
System.out.println();
printArray(arr2);
}
static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
class UseArray {
public static void main(String[] args) {
int[] arr = { 1, 2, 3 };
// 拷贝扩容
arr = Arrays.copyOf(arr, 10);
printArray(arr);
// 也能截取
arr = Arrays.copyOf(arr, 2);
printArray(arr);
}
static void printArray(int[] arr) {
System.out.println(Arrays.toString(arr));
}
}
import java.util.Arrays;
class UseArray {
public static void main(String[] args) {
int[] arr = { 1, 2, 3 };
printArray(arr);
arr = extendArray(arr);
printArray(arr);
addArray(arr);
printArray(arr);
}
static void printArray(int[] arr) {
System.out.println(Arrays.toString(arr));
}
// 传入的是arr所指的地址
static void addArray(int[] arr) {
arr[0] = 10086;
}
static void extendArray(int[] arr) {
arr = Arrays.copyOf(arr, 10);
return arr;
}
}
可变长参数
只能放最后一个参数位置，作为数组形式使用。
class UseArray {
public static void main(String[] args) {
System.out.println(sumup("Hello", 1, 2, 3, 4, 5, 6, 7));
}
public static int sumup(String str, int... nums) {
int sum = 0;
System.out.println("Input String: " + str);
for (int i = 0; i < nums.length; i++) {
sum += nums[i];
}
return sum;
}
}
二维数组
class UseArray {
public static void main(String[] args) {
int[][] arrs1 = new int[3][5];
arrs1[0][0] = 0;
printArrays(arrs1);
int[][] arrs2 = new int[3][];
arrs2[0] = new int[5];
arrs2[1] = new int[3];
arrs2[2] = new int[1];
printArrays(arrs2);
int[][] arrs3 = { { 1, 2, 3 }, { 2, 3 }, { 3 } };
printArrays(arrs3);
return;
}
public static void printArrays(int[][] arrs) {
for (int i = 0; i < arrs.length; i++) {
for (int j = 0; j < arrs[i].length; j++)
System.out.print(arrs[i][j] + " ");
System.out.println();
}
System.err.println("--------------");
return;
}
}
面向对象基础
public class Person {
String name;
int age;
public void speak(String words) {
System.out.println(name + "say: " + words);
}
public void jump() {
System.out.println(name + "jumps to " + age);
}
}
public class Test {
public static void main(String[] args) {
Person person = new Person();
person.name = "小明";
person.age = 18;
person.speak("哈哈哈");
person.jump();
}
}
- 类由成员变量和方法组成
- 类中定义的变量是成员变量，实例化后存在堆空间中，创建后就有默认值，不会因为没有初始化成员变量而报错。
- 局部变量的优先级高于成员变量，在类方法中的同名局部变量会先于成员变量。如果在方法中需要使用成员变量，需要加上
this.来访问。
方法重载
一个类中定义多个相同名称的方法，但是参数列表不同（类型、顺序、个数不同都算不同）。这与形参名、方法访问修饰符、返回值类型无关！
可以参考println()函数的实现，有很多方法重载的例子。、
public void println(boolean x) {
if (getClass() == PrintStream.class) {
writeln(String.valueOf(x));
} else {
synchronized (this) {
print(x);
newLine();
}
}
}
public void println(char x) {
if (getClass() == PrintStream.class) {
writeln(String.valueOf(x));
} else {
synchronized (this) {
print(x);
newLine();
}
}
}
构造方法
类中的特殊方法，与类名同名。
没有返回值类型，只在创建对象时调用，无法通过方法调用。
没有在类中显式定义构造方法，由编译器提供无参构造方法。
构造方法也可以重载！在定义带参构造后需要补充无参构造！
public class Person {
String name;
int age;
public Person() {
System.out.println("Person created!");
}
public Person(String name) {
this.name = name;
}
public void speak(String words) {
System.out.println(name + "say: " + words);
}
public void jump() {
System.out.println(name + "jumps to " + age);
}
}
对象的创建步骤
this关键字
指向当前实例对象。实际是对象在虚拟机中的堆地址（在new的时候就已经确定）
- 在类方法中，可以避免与局部同名变量冲突。用于调用成员变量/方法。
- 构造方法内自调用
this()
public class Person {
String name;
int age;
public Person() {
System.out.println("Person created!");
}
public Person(String name) {
this.name = name;
}
public Person(String name, int age) {
this(name);
this.age = age;
}
public void speak(String words) {
System.out.println(name + "say: " + words);
}
public void jump() {
System.out.println(name + "jumps to " + age);
}
}
封装
隐藏必要的对象内部实现细节，控制对象属性、方法的使用与修改权限。
使用访问修饰符private（私有，仅本类可见）。
属性的访问与修改使用getter和setter。
public class Person {
String name;
int age;
private int score;
public void setScore(int score) {
if (score >= 0 && score <= 100)
this.score = score;
else
this.score = 0;
}
public int getScore() {
return this.score;
}
}
继承
使用extends关键字继承父类，实例化子类时，会先调用父类的构造方法，然后调用子类的构造方法。
默认会调用无参父类构造，如果需要调用带参构造，使用super(a,b,c...)调用。
子类创建对象时并没有创建父类对象，只是在子类空间中创建了super指向的父类空间，所以只有一个子类对象实例。
public class Animal {
private String name;
int age;
private double price;
public Animal() {
System.out.println("Animal Created!");
}
public Animal(String name) {
System.out.println("Animal with name Created!");
setName(name);
}
public Animal(String name, int age, double price) {
this.name = name;
this.age = age;
this.price = price;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
public class Dog extends Animal {
int age;
public Dog() {
super("MAKA");
System.out.println("Dog created!");
this.age = 233;
super.age = 666;
}
public void speak() {
System.out.println(getName() + " wang wang!");
}
}
public class Test {
public static void main(String[] args) {
Dog pt = new Dog();
System.out.println(pt.age);
pt.speak();
return;
}
}
// Animal with name Created!
// Dog created!
// 233
// MAKA wang wang!
属性的继承
父类的所有属性都可以被继承，但是私有属性不能被访问。
当子类和父类有同名属性时，通过super关键字区分，没标注this/super优先访问this的。
public class Sup {
int a;
int b;
}
public class Sub extends Sup {
int b;
public void speak() {
System.out.println("a: " + a);
System.out.println("this.b: " + this.b);
System.out.println("super.b: " + super.b);
}
}
public class Test {
public static void main(String[] args) {
Sub sub = new Sub();
sub.a = 1;
sub.b = 2;
sub.speak();
return;
}
}
// a: 1
// this.b: 2
// super.b: 0
方法的覆盖（重写）
当父类提供的方法无法满足子类需求时，对父类相同的方法（包括方法名和参数列表结构完全一致）覆盖。
子类覆盖的方法不能比父类的方法可见性小。父类私有的方法不会被重写（相当于不可见）。
子类返回值类型只能与父类一样或者是父类的子类和null，如果是基本数据类型，需要完全一致。
public class Sup {
int a;
int b;
Sup speak() {
return new Sub();
}
Sub speak(String words) {
System.out.println("233");
return new Sub();
}
}
public class Sub extends Sup {
int b;
Sub speak(String words) {
super.speak(words);
System.out.println("666");
return new Sub();
}
}
public class Test {
public static void main(String[] args) {
Sub sub = new Sub();
sub.a = 1;
sub.b = 2;
sub.speak();
sub.speak("");
return;
}
}
// 233
// 666
访问修饰符
多态
父类引用指向子类对象，产生了多态。（向上转型、里氏替换）
要求有继承关系，多态只能调用父类有的属性、方法，不能调用子类有的。
如果子类有父类方法的重写，则会调用子类的重写方法。
Pet pet = new Dog();
使用场景1：父类作为方法的形参实现多态，使得方法参数类型更宽泛（能用多个子类作为参数类型）
public class Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void eat() {
System.out.println("Animal eat what?");
}
public void feed(Animal animal) {
animal.eat(); // 实际上是调用子类的eat重写方法
}
}
public class Dog extends Animal {
public void eat() {
System.out.println("Dog eat something!");
}
}
public class Cat extends Animal {
public void eat() {
System.out.println("Cat eat fish!");
}
}
public class Test {
public static void main(String[] args) {
Animal dog = new Dog();
dog.eat();
Animal cat = new Cat();
cat.eat();
}
}
// Dog eat something!
// Cat eat fish!
使用场景2：父类作为方法的返回值实现多态，使得方法返回不同的子类对象（能用多个子类作为返回值）
public class Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void eat() {
System.out.println("Animal eat what?");
}
public void feed(Animal animal) {
animal.eat();
}
public Animal getAnimal(String type) {
if (type.equals("Dog"))
return new Dog();
if (type.equals("Cat"))
return new Cat();
return null;
}
}
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
animal = animal.getAnimal("Cat");
animal.eat();
}
}
// Cat eat fish!
向下转型
父类无法调用子类的特有方法，需要强转（向下转型）后才能调用。要保证强转后的子类确实有这个方法。
public class Test {
public static void main(String[] args) {
Animal animal = new Cat();
if (animal instanceof Cat) {
Cat cat = (Cat) animal;
cat.eatFish(); // Cat独有的方法
}
}
}
抽象类和抽象方法
https://www.bilibili.com/video/BV1994y1r7uV/?p=83&spm_id_from=pageDriver&vd_source=9cf1572a869a6a64c75ab4bdbe55f984