java学习（ 持续更新）

x.append(y) y接在x后面

英文

balance：余额
extends：继承
override：重写，覆盖
annual：年薪

快捷键

快捷键 ctrl+h 看到类的继承关系
定位 ctrl + b
一键整理代码格式的快捷键是 Ctrl + Alt + L

数组

创建数组

int[] numbers = new int[5]; // 创建一个包含 5 个整数的数组

可以在创建数组的同时赋初值，也可以单独初始化数组元素：

int[] numbers = {1, 2, 3, 4, 5}; // 初始化数组并赋初值
numbers[0] = 10; // 单独初始化数组元素

数组初始化为 []（空括号）和 null 有着不同的含义：

数组初始化为 []：

当我们声明一个数组并初始化时，如果使用 [] 表示空的初始值，即数组已经创建但没有元素被赋值。这种情况下，数组的长度为0。
示例代码：

int[] numbers = {}; // 声明一个空数组，长度为0

数组初始化为 null：

当一个数组被赋值为 null，表示该数组引用不指向任何有效的数组对象，即数组对象不存在。这时数组变量虽然声明了，但它并没有引用任何实际的数组对象，也没有分配内存空间。

int[] numbers = null; // 将数组引用变量赋为null，表示该引用不指向任何数组对象

字符串

比较两个字符串内容是否相当：str1.equals(str2)

解题思路

先完成代码的正常业务，再考虑健壮性。

包装类

这里直接用double的话无法解决数组为空的情况的返回。 可以用包装类Double解决。

 public class Homework01{

	public static void main(String[] args){
			A01 p1 = new A01();
			double num[] =  {1,3,4,5};
			Double res = p1.max(num);
			if (res != null){
				System.out.println(p1.max(num));
			}
			
	}
}
class A01 {
	// 要考虑代码的健壮性

	public Double max(double[] array){
		// this.array=array;
		if(array != null && array.length > 0){
			double max = array[0];
		for(int i = 1; i < array.length ; i ++){
			if (array[i] > max){
				max = array[i];
			}
		}
		return max;
	}
	else return null;
		

}
}

运算符

运算符的优先级是固定的，按照优先级从高到低的顺序排列如下：

一元运算符：++, --, ~, !
乘性运算符：*, /, %
加性运算符：+, -
移位运算符：<<, >>, >>>
关系运算符：<, >, <=, >=, instanceof
相等运算符：==, !=
位运算符 AND：&
位运算符 XOR：^
位运算符 OR：|
逻辑运算符 AND：&&
逻辑运算符 OR：||
条件运算符：? :
赋值运算符：=, +=, -=, *=, /=, %=, &=, ^=, |=, <<=, >>=, >>>=

j=i++； 先赋值再自增；
j=++i； 先自增再赋值。

在构造器中用另一个构造器

class Employee {
	
	String name;
	char gender;
	int age;
	String career;
	double sale;
	public Employee(String job,double sale){
		this.job = job;
		this.sale = sale;
		
	}
	public Employee(String name,char gender, int age){
		this.name = name;
		this.gender = gender;
		this.age = age;
	}
	public Employee(String job,double sale, String name,char gender,int age){
		this(name, gender, age);//访问之前的构造器
		this.job = job;
		this.sale = sale;
	}
	
}

随机数

import java.util.Random;

public class Main {
    public static void main(String[] args) {
        Random random = new Random();
        int randomNumber = random.nextInt(3); // 生成一个范围在 0 到 2 的随机数
        System.out.println(randomNumber);
    }
}

switch

switch (expression) {
    case value1:
        // 当 expression 的值等于 value1 时执行的代码块
        break;
    case value2:
        // 当 expression 的值等于 value2 时执行的代码块
        break;
    // 可以有更多的 case 分支
    default:
        // 当 expression 的值与所有 case 不匹配时执行的代码块
}

接收用户的输入

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入一个数字：");
        
        // 接收用户输入的数字
        int number = scanner.nextInt();
        
        System.out.println("您输入的数字是：" + number);

        scanner.close();
    }
}

可变参数

 public static void printNumbers(int... numbers) {
  
}

继承和多态

看的韩顺平老师的课 通过廖雪峰的网站补充 记录如下：
如果父类没有默认的构造方法，子类就必须显式调用super()并给出参数以便让编译器定位到父类的一个合适的构造方法。
向上转型实际上是把一个子类型安全地变为更加抽象的父类型：

Student s = new Student();
Person p = s; // upcasting, ok
Object o1 = p; // upcasting, ok
Object o2 = s; // upcasting, ok

和向上转型相反，如果把一个父类类型强制转型为子类类型，就是向下转型（downcasting）。例如：

Person p1 = new Student(); // upcasting, ok
Person p2 = new Person();
Student s1 = (Student) p1; // ok
Student s2 = (Student) p2; // runtime error! ClassCastException!

Person类型p1实际指向Student实例，Person类型变量p2实际指向Person实例。在向下转型的时候，把p1转型为Student会成功，因为p1确实指向Student实例，把p2转型为Student会失败，因为p2的实际类型是Person，不能把父类变为子类，因为子类功能比父类多，多的功能无法凭空变出来。

Java的实例方法调用是基于运行时的实际类型（等号右边）的动态调用，而非变量的声明类型（等号左边）。这个非常重要的特性在面向对象编程中称之为多态。多态是指，针对某个类型的方法调用，其真正执行的方法取决于运行时期实际类型的方法。多态具有一个非常强大的功能，就是允许添加更多类型的子类实现功能扩展，却不需要修改基于父类的代码。

Java 中的属性访问是根据编译时类型确定的，而方法访问是根据运行时对象的类型确定的。

属性访问：根据编译时类型确定。即使引用指向的对象是子类的实例，也只有在引用的类中定义的属性才能被访问，而不是实际对象的类型。

方法访问：根据运行时对象的类型确定。在调用对象的方法时，实际执行的是该对象所属类中定义的方法，而不是引用类型指定的方法。这种行为被称为动态绑定或运行时多态。

Object类