JAVA基础
数组
动态分配方式一
数据类型 数组名[] = new 数据类型[大小]
int a[] =new int[50];动态分配方式二
double scoures[];
scours = new double[100];静态分配方式：
数据类型 数组名[] = {元素值,元素值……}
方法
方法重载（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("Frieren",1000)
}
//执行结果：输出"构造器被调用,初始化(对象)完成"，证明调用了构造器方法。
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 //不合理
Dog extend Animal //合理super 关键字
super 代表父类的引用，用于访问父类的属性、方法、构造器
基本语法：
访问父类的属性，但不能访问父类的 private 属性
super.属性名；访问父类的方法，不能访问父类的 private 方法
super.方法名(参数列表)；访问父类的构造器
super(参数列表)；在能放在构造器的第一句，只能出现一句！
super 带来的便利：
调用父类的构造器的好处 (分工明确，父类属性由父类初始化，子类属性由子类初始化)。
当子类中有和父类中的成员 (属性和方法) 重名时，为了访问父类的成员，必须通过 super。如果没有重名，使用 super、this、直接访问效果是一样的。
super 的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以使用 super 去访问爷爷类的成员；如果多个基类中都有同名的成员，使用 super 访问遵循就近原则。
A > B > C
方法重写 / 覆盖
基本介绍：
方法覆盖 (重写) 就是子类有一个方法，和父类的某个方法的名称、返回类型、参数都一样，那么我们就说子类的这个方法覆盖了父类的哪个方法。
例子：
class Anime {
public void cry() {
System.out.println("芙莉莲是我老婆");
}
}
class Anime_Wife extends Anime {
public void cry() {
super.cry(); // 调用父类的cry()方法
System.out.println("拾雪是我老婆");
}
}
public class Main {
public static void main(String[] args) {
Anime_Wife animeWife = new Anime_Wife();
animeWife.cry();
}
}注意事项：
子类的方法的参数、方法名称，要和父类方法的参数，方法名称完全一样。
子类方法的返回类型和父类方法返回类型一样，或者是父类返回类型的子类
如： 父类 返回类型是 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));例子：
FH fh = new FH("杉秋");
Anime anime = new Anime("芙莉莲");
Wife wife = new Wife("老婆");
fh.Wife_manage(anime, wife);
Shi_Xue shi_xue = new Shi_Xue("拾雪");
Wife2 wife2 = new Wife2("二老婆");
fh.Wife_manage(shi_xue, wife2);
// 杉秋的 老婆 是 芙莉莲
public void Wife_manage(Wife wife, Anime anime) {
System.out.print(name + "的" + wife.getName() + "是" + anime.getName());
}
// 杉秋的 二老婆 是 拾雪
public void Wife_manage(Wife2 wife2, Shi_Xue shi_xue) {
System.out.print(name + "的" + wife2.getName() + "是" + shi_xue.getName());
}
/*
使用多态机制，可以统一的管理不同类型的老婆[doge嘿嘿嘿]
wife编译类型是Wife，可以指向(接收)Wife子类的对象
manage编译类型是Manage，可以指向(接收)Manage子类的对象
*/
public void Wife_manage(Manage manage,Wife wife) {
System.out.println(name + "的" + manage.getName() + "是" + wife.getName());
}向上转型：
（把子类提高到父类的层次）如：Manage manage = new Wife ();
1. 本质：
父类的引用指向了子类的对象
2. 语法：
父类类型 引用名 = Wife 子类类型 ();
3. 特点：
编译类型看左边，运行类型看右边。
可以调用父类中的所有成员 (需遵守访问权限)，不能调用子类中特有成员；最终运行效果看子类的具体实现！
向下转型：
语法：子类类型 引用名 = (子类类型) 父类引用；
Wife wife = (Wife) manage;
只能强转父类的引用，不能强转父类的对象；
要求父类的引用必须指向的是当前目标类型的对象；
可以调用子类类型中所有的成员。
属性重写
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 () 主动出发垃圾回收机制。
例子：
mihoyo Genshin_Impact = new mihoyo("原神");
Genshin_Impact = null; //这时，mihoyo对象就是一个垃圾对象，垃圾回收器就会回收(销毁)对象
//在销毁对象前，会调用该对象的finalize方法，
//程序员就可以在这个方法中写自己的业务逻辑代码(如释放资源、数据库连接或者打开的文件……)
//如果程序员不重写finalize方法，那么就会调用Object类的finalize方法，即默认处理；
//如果程序员重写了finalize方法，就可以实现自己的逻辑
当Genshin_Impact = null执行时，Genshin_Impact指向mihoyo的线就断了，此时，mihoyo对象就成了一个垃圾对象作者：FichteHerbst.
文章地址：
版权声明: 本站所有文章除特别声明外 ，均采用 CC BY-NC-SA 4.0 协议。
非商业转载及引用请注明出处（作者、原文链接），商业转载请联系作者获得授权。
