数组：
动态分配方式一：
数据类型 数组名[] = new 数据类型[大小]
int a[] =new int[8];
动态分配方式二：
double scoures[];
scours = new double[35];
静态分配方式：
数据类型 数组名[] = {元素值,元素值……}
方法：
方法重载（OverLoad）:
Java允许同一个类中，多个同名方法的存在，但要求形参列表不一致；
可变方法：
java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。
基本语法：访问修饰符 返回类型 方法名（数据类型...形参名）{}
public int sum (int...nums){}
int... 表示接受的是可变参数。类型是int，即可以接收多个int(0~多)
构造器
基本语法：
[修饰符] 方法名(形参列表){方法体};
主要作用：
是完成对新对象的初始化（而不是创建对象）。
如：per p = new per()；
此时p指向一个对象，对象的空间已经有了，对象里面的值的初始化就由构造器来完成。
特点：
- 方法名与类名相同；
- 没有返回值；
- 在创建对象时，系统会自动的调用该类的构造器完成对对象的初始化。
说明：
- 构造器的修饰符可以默认；
- 构造器没有返回值；
- 方法名和类名字必须一样；
- 参数列表和成员方法一样的规则；
- 构造器的调用系统完成。
例子：
在创建人类的对象时，就直接指定这个对象的年龄和姓名。
//编写一个main方法
public static void main(String[] args) {
//当我们new一个对象时，直接通过构造器指定名字和年龄
ew Person("smith",80)
}
//执行结果：输出"构造器被调用~~完成对象的初始化"，证明调用了构造器方法。
========================================================================
class Person{
Sustem.out.pringtin("构造器被调用~~完成对象的初始化")
String name;
int age;
/*
构造器解读：
1、构造器没有返回值，也不能写void；
2、构造器的名称和类Person一样
3、(String pName, int pAge)是构造器形参列表，规则和成员方法一样。
*/
public Person(String pName, int pAge){
name = pName;
age = pAge;
}
}
访问修饰符：
java提供四种访问修饰符号控制方法和属性（成员变量）的访问权限（范围）：
- public(公共的)：
对外公开；
一个java文件中只可以有一个public修饰的类，并且类名需要和文件名相同 - protected(受保护的)：
对子类和同一包中的类公开； - default（默认的）：
默认修饰符，没有修饰符号，向同一个包的类公开； - private（私有的）：
只有类本身可以访问，不对外公开。
封装：
封装的实现步骤（三步）
- 将属性进行私有化private 【不能直接修改属性】
- 提供一个公共的（public）set方法，用于对属性判断并赋值
public void setXxx(类型 参数名){ //Xxx表示某个属性
//加入数据验证的业务逻辑
属性 = 参数名；
}
- 提供一个公共的（public）get方法，用于获取属性的值
public 数据类型 getXxx(){ //权限判断，Xxx某个属性
return xx;
}
继承：
继承可以解决代码复用，让我们的编程更加接近人类思维，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽出抽象的父类，在父类中定义这些相同的属性和方法，所有的子类补血药重新定义这些属性和方法，只需要通过extends来声明继承父类即可。
基本语法：
calss 子类 extend 父类{}
说明：
- 子类就会自动拥有父类定义的属性和方法；
- 父类又叫超类，基类；
- 子类又叫派生类。
注意：
- 子类继承了所有的属性和方法，但是私有属性和方法不能在子类中直接访问，要通过公共的方法去访问；
- 子类必须调用父类的构造器，完成父类的初始化；
- 当创建子类对象时，不管使用子类哪个构造器，默认情况下总会去调用父类的无参构造器，如果父类没有提供无参构造器，则必须在子类的构造器中用super去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过；
- 如果希望指定去调用父类的某个构造器，则显示的调用一下；
- super在使用时，需要放在构造器第一行；
- super()和this()都只能放在构造器第一行，因此这两个方法不能共存一个构造器;
- java所有类都是Object的子类，Object是所有类的基类；
- 父类构造器的调用不限于直接父类！将一直往上追溯到Object类（顶级父类）;
- 子类最多只能继承一个父类（指直接继承），即java中是单继承机制；如何让A类继承B类和C类？可以先A继承B，然后B再继承C；
- 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系；
如：Music extend Person //不合理;
Cat extend Animal //合理
super关键字：
super代表父类的引用，用于访问父类的属性、方法、构造器
基本语法：
- 访问父类的属性，但不能访问父类的private属性
super.属性名； -
访问父类的方法，不能访问父类的private方法
super.方法名(参数列表)； -
访问父类的构造器
super(参数列表)；在能放在构造器的第一句，只能出现一句！
super带来的便利：
- 调用父类的构造器的好处(分工明确，父类属性由父类初始化，子类属性由子类初始化)
- 当子类中有和父类中的成员(属性和方法)重名时，为了访问父类的成员，必须通过super。如果没有重名，使用super、this、直接访问效果是一样的。
- super的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用super去访问爷爷类的成员；如果多个基类中都有同名的成员，使用super访问遵循就近原则。A->B->C
方法重写/覆盖：
基本介绍：
方法覆盖(重写)就是子类有一个方法，和父类的某个方法的名称、返回类型、参数都一样，那么我们就说子类的这个方法覆盖了父类的哪个方法。
例
class Animal{
public void cry(){
System.out.print("动物叫唤");
}
}
class Dog extend Animal{
public void cry(){
System.out.print("小狗汪汪叫");
}
}
注意事项：
- 子类的方法的参数、方法名称，要和父类方法的参数，方法名称完全一样。
- 子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
比如： 父类 返回类型是 Obje，子类返回方法类型是String
public Object getInfo(){}
public String getInfo(){}
- 子类方法不能缩小父类方法的访问权限
void sayOK(){}
public void sayOK(){}
多态：
我们通过不同的参数个数去调用sum方法，就回去调用不同的sum方法
因此对sum方法来说，就是多种状态的体现
A a = new A();
System.out.print(a.sum(10,30));
System.out.print(a.sum(10,30,50));
例
main方法：
Master tom = new Master("汤姆");
Dog dog = new Dog("大黄");
Bone bone = new Bone("大棒骨");
tom.feed(dog,bone);
Cat cat = new Cat("小花猫");
Fish fish = new ("黄花鱼");
tom.feed(cat,fish);
===========================================================================
//主人给 小狗 喂食 大棒骨
public void feed(Dog dog,Bone bone){
System.out.print("主人" + name + "给" + dog.getName + "吃" + bone.getName);
}
//主人给 小花猫 喂食 黄花鱼
public void feed(Cat cat,Fish fish){
System.out.print("主人" + name + "给" + cat.getName + "吃" + fish.getName);
}
/*
使用多态机制，可以统一的管理主人喂食的问题
animal编译类型是Animal，可以指向(接收)Animal子类的对象
food编译类型是Food，可以指向(接收)Food子类的对象
*/
public void feed(Animal animal,Food food){
System.out.print("主人" + name + "给" + animal.getName + "吃" + food.getName);
}
向上转型：
（把子类提高到父类的层次）如：Animal animal = new Cat();
1. 本质：
父类的引用指向了子类的对象
2. 语法：
父类类型 引用名 = new 子类类型();
3. 特点：
编译类型看左边，运行类型看右边。
可以调用父类中的所有成员(需遵守访问权限)，不能调用子类中特有成员；最终运行效果看子类的具体实现！
向下转型：
- 语法：子类类型 引用名 = (子类类型) 父类引用；
Cat cat = (Cat) animal; - 只能强转父类的引用，不能强转父类的对象；
- 要求父类的引用必须指向的是当前目标类型的对象；
- 可以调用子类类型中所有的成员。
属性重写：
class Base{
int count = 10;
}
class Sub extends Base{
int count = 20;
}
==运算符
==既可以判断基本类型，又可以判断引用类型；==如果判断基本类型，判断的值是否相等。示例：int i = 10;double d = 10.0;==如果判断引用类型，判断的是地址是否相等，即判定是不是同一个对象。
例子：
A obj1 = new A();
A obj2 = new A();
A obj3 = obj1; //引用赋值，其实给的是地址
equals方法：
- equals是Object类中方法，只能判断引用类型。
- 默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等。
hashCode方法：
- 提高具有哈希结构的容器的效率；
- 两个引用，如果指向的是同一个对象，则哈希值肯定是一样的；
- 两个引用，如果指向的是不同对象，则哈希值是不一样的；
- 哈希值主要根据地址号来的，不能完全将哈希值等价于地址；
- 后面在集合中，hashCode如果需要的话，也会重写。
toString方法：
基本介绍：
- 默认返回：全类名+@+哈希值的十六进制，[查看Object的toString方法]；子类往往重写toString方法，用于返回对象的属性信息。
- 重写toString方法，打印对象或者拼接对象时，都会自动调用该对象的toString形式；
- 当直接输出一个对象时，toString方法会被默认的调用。
finalize方法：
- 当对象被回收时，系统自动调用该对象的finalize方法，子类可以重写该方法，做一些释放资源的操作。
- 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。
- 垃圾回收机制的调用，是由系统来决定，也可以通过System.gc()主动出发垃圾回收机制。
例
Car bmw = new Car("宝马");
bmw = null; //这时，Car对象就是一个垃圾对象，垃圾回收器就会回收(销毁)对象
//在销毁对象前，会调用该对象的finalize方法，
//程序员就可以在这个方法中写自己的业务逻辑代码(如释放资源、数据库连接或者打开的文件……)
//如果程序员不重写finalize方法，那么就会调用Object类的finalize方法，即默认处理；
//如果程序员重写了finalize方法，就可以实现自己的逻辑
当bmw = null执行时，bmw指向Car的线就断了，此时，Car对象就成了一个垃圾对象
哈哈，很好
感谢认可哈哈🌹