记录一些自己遗漏或者不熟悉的知识点
小知识：
快速创建main函数：psvm
快速正序for循环：对象名.fori
快速倒序for循环：对象名.forr

位(bit)：一个数字0或者一个数字1，代表一位。
字节(Byte)：每8个位是一个字节，这是数据存储的最小单位。
1 Byte = 8 bit；
1 KB = 1024 Byte
1 GB = 1024 KB
1 TB = 1024 GB

字符串常量：“”
整数常量、浮点数常量：直接输出
字符常量：‘’
布尔常量：true、false
空常量：空常量不能直接打印输出，不能放如null

注意 ‘ ’ 之间不能不写字符，且有且仅有一个；

特点：代码需要进行特殊的格式处理，不能自动完成；
格式：范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据；

格式：
数据类型 变量名称 = 条件判断 ？表达式a ：表达式b；
流程：
首先判断条件是否成立，
如果条件成立，则将表达式a的值赋给左侧的变量；
如果条件不成立，则将表达式b的值赋给左侧的变量；

注意事项：必须同时保证表达式a和表达式b都符合左侧数据类型的要求。

方法其实就是若干语句的功能集合
定义一个方法的格式：

public static void 方法名称(){
		方法体
	}

定义方法的完整格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，…）{
方法体
return 返回值；
}

方法名称命名规则和变量一样，使用小驼峰
方法体：也就是大括号当中可以包含任意条语句
修饰符：基础（public static）
return：两个作用，其中一个是将后面的返回值还给掉用处；

注意事项：
1.方法应该定义在类中
2.方法定义的顺序无所谓
3.方法的定义不能产生嵌套包含的关系
43.方法定义好不会执行，如果想要执行需要进行调用

格式：
方法名称()；

方法的重载（overload）：多个方法的名称一样，但是参数列表不一样

public class cda {
    public static void main(String[] args) {

        System.out.println("Hello World"); // 打印 Hello World
        System.out.println(sum(1,2));
        System.out.println(sum(10,20,30));

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

方法重载与下列因素有关：
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同

方法重载与下列因素无关（错误）：
1.与参数的名称
2.与方法的返回值类型

构造方法是专门用来创建对象的，当我们通过关键字new来创建对象时，其实就是在调用构造方法，格式：
public 类名称(参数类型 参数名称){
方法体；
}

注意事项：
1.构造方法的名称必须和所在类名称完全一致，包括大小写。
2.构造方法不要写返回值类型，连void也不能写。
3.构造方法不能return一个具体的返回值。
4.如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数，方法体内什么事都不做。
5.一旦编写了至少一个构造方法，那么编译器将不再赠送。
6.构造方法也是可以重载的。
重载：方法名称相同，参数列表不同。

一个标准的类通常具备以下四个条件：
1、所有成员变量都要用private关键字修饰
2、为每一个成员变量编写一对Getter/Setter方法
3、编写一个无参数的构造方法
4、编写一个全参数的构造方法

这样的标准类也叫做Java Bean

两种常见的数组初始化方式：
1.动态初始化（指定常数）
2.静态初始化（指定内容）

动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度]；
右侧的new代表创建数组的动作；
右侧数据类型一定要和左侧数据类型保持一致；
例如：创建一个能存五个字符串的数组：

String[] zifu = new String[5];

静态初始化基本格式：
数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，…};

使用静态初始化数组的时候，格式还以省略
省略格式：
数据类型[] 数组名称 = {元素1，元素2，…}；

注意事项：
静态初始化和动态初始化都可以拆分成两部分写，但是静态初始化使用省略格式的时候，则不能拆分成两部分写

一些异常情况：
空指针异常：
数组必须进行new初始化才能使用其中的元素，如果只是赋值了一个null，没有进行new创建，那么会发生空指针异常（nullpointerexception）

数组长度：数组名.length;

Java的内存需要划分成为5个部分：
1.栈（Stack）：存放的都是方法中的局部变量。
局部变量：方法的参数，或者是方法内部的变量
作用域：一旦超出作用域，立刻从栈内存当中消失
2.堆（Heap）:凡是new出来的东西，都在其中。
堆内存里面的东西都有一个地址值：16进制
如果是整数： 默认为0
如果是浮点数 默认为0.0
如果是字符 默认为“u0000”
如果是布尔 默认为false
如果是引用类型 默认为null
3.方法区（Method Area）：存储class相关信息，包含方法的信息。
4.本地方法栈（Native Method Stack）:与操作系统相关
5.寄存器（pc Register）：与CPU相关

一些基本概念：
定义一个类，应该由两部分组成：成员变量、成员方法。
注意事项：
1.成员变量是直接定义在类当中的，在方法外边。
2.成员方法不要写static关键字。

通常情况下，一个类不能直接使用，需要根据类创建一个对象，才能使用：
1、导包，也就是指出需要使用的类，在什么位置。
import 包名称.类名称；
对于和当前类属于同一个包的情况，可以省略导包语句不写。

2、创建，格式：
类名称 对象名 = new 类名称()；

3、使用
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成语昂方法名(参数)
（也就是，想用谁就用对象名点谁）

1.当一个对象作为参数，传递到方法中时，实际上传递进去的是对象的地址值

2.当使用一个对象类型作为方法的返回值时，返回值其实就是对象的地址值

首先是对象个命名格式：
类名称 对象名 = new 类名称 ()；
而匿名对象就是只有右边的对象，没有左边的名字和赋值运算符，格式：
new 类名称()；

注意事项：
匿名对象只能使用唯一的一次，下次再用必须再创建一个新的对象。
使用建议：
如果确定一个对象只需要用=用到唯一的一次，就可以使用匿名对象。

使用匿名对象来传参数：

1、定义的位置不同
局部变量：在方法的内部。
成员变量：在方法的外部，直接定义在类当中。

2、作用范围不一样
局部变量：只有在方法中有效
成员变量：整个类全部都可以使用

3、默认值不一样
局部变量：没有默认值，需要手动进行赋值
成员变量：如果没有赋值，存在默认值

4、内存的位置不一样
局部变量：位于栈
成员变量：位于堆

5、生命周期不一样
局部变量：随着方法进栈而诞生，出栈而消失
^
成员变量：随着对象创建而诞生，被垃圾回收而消失

注：方法的参数就是局部变量
参数在被方法调用的时候必然会被赋值，因此能够被直接输出

引用类型的一般使用步骤
1、导包
import 包路径.类名称
如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
只有Java.lang包下的内容不需要导包，其他的包都需要import语句。
2、创建
类名称 对象名 = new 类名称();
3、使用
对象名.成员方法名()

定义了一个person类，然后创建了对象数组：

Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。

Array.方法名称
一些常用的方法：
public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1，元素2，元素3，…]）
public static void sort(数组)：对参数数组进行升序排序

里面有很多数学运算相关的静态方法
其中的一些常用方法；
public static double abs(double num)：获取绝对值
public static double ceil(double num)：向上取整（不小于num 的最小整数）
public static double floor(double num)：向下取整（不大于num的最大整数）
public static double long round(double num)：四舍五入取整数

面向对象的三大特征：封装、继承、多态

封装性在Java当中的体现：
1.方法就是一种封装
2.关键字private也是一种封装

封装就是将一些细节信息隐藏起来，对于外界不可见。

一旦使用了private进行修饰（参数），那么本类当中仍然可以随意访问。但是！超出了本类范围之外就不能再直接访问了。如下图所示：
定义了一个person类

在main函数调用person类的age时出错
解决办法：在person类中设置下面两个函数（间接方法）

public void setAge(int num){
	age = num;
}
public int getAge(){
	return age;
}

所以，间接访问private成员变量，就是定义一对Getter/Setter方法
必须叫setXxx或者是getXxx命名规则。
对于Getter来说，不能有参数，返回值类型和成员变量对应；
对于Setter来说，不能有返回值，参数类型和成员变量对应。

对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变，例：

当方法的局部变量和类成员重名的时候，根据“就近原则”，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量名

“通过谁调用的方法，谁就是this”

一旦使用了static关键字，那么这样的内容不再属于对象自己，而是属于类，所以凡是本类的对象，都同享同一份。

一旦使用static修饰了成员方法，那么这就成为了静态方法，静态方法不属于对象，而是属于类的。

如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。

对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。

无论是成员变量还是成员方法，如果用了static修饰，都推荐使用类名称进行调用：
静态变量：类名称.静态变量；
静态方法：类名称.静态方法()；

但是对于本类当中的静态方法，可以省略类名称；

注意事项：
1.静态方法不能直接访问非静态
原因：因为在内存当中是先有静态内容，后有非静态内容
2.静态方法当中不能用this关键字
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

public class MyClass {
    int num;
    static int numStatic;

    public void method(){
        System.out.println("这是一个普通方法");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(numStatic);
    }
    public static void methodStatic(){
        System.out.println("这是一个静态方法");
        //静态方法不能直接访问非静态变量
        System.out.println(num);//错误
        //静态方法可以直接访问静态变量
        System.out.println(numStatic);
    }
}

静态代码块的格式：

public class 类名称 {
    static {
        //静态代码块的内容
    }
}

特点是：
当第一次使用本类的时候，静态代码块执行唯一的一次。

ps：静态内容总是优先于非静态，所以静态代码块比构造方法先执行。

静态代码块的典型用途；
用来一次性地对静态成员变量进行赋值。

数组的长度是不可以发生改变的，但是ArrayList的长度是可以随意变化的。
对于ArrayList来说，有一个“”代表泛型
泛型：也就是装在集合当中的所有元素，全都是统一的E类型。
注意：泛型只能是引用类型，不能是基本类型（例：int）。

import java.util.ArrayList;

public class Demo2ArrayList {
    public static void main(String[] args) {
        //创建了一个ArrayList集合，集合名称是list，里面装的全都是String字符串类型的数据
        ArrayList<String> list = new ArrayList<>();
    }
}

注意事项：
对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。如果内容是空，得到的就是空的中括号（[]）。

ArrayList的一些常用方法：
add：添加数据
get(int index)：获取元素，index是索引编号
remove(int index)：删除元素，index是索引编号
size ()：获取集合的尺寸长度，返回元素个数
(索引值从0开始)

如果希望向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”：
基本类型 包装类
byte Byte
short Short
int Integer【特殊】
long Long
float Float
double Double
char Character【特殊】
boolean Boolean

字符串是常量，它们的值在创建之后就不能更改。
创建字符串的常见3+1种方式：
三种构造方法：
public String( )，创建一个空白字符，不含邮任何内容；
public String(char[] array)，根据字符数组的内容，来创建对应的字符串；
public String(byte[] array)，根据字节数组的内容，来创建对应的字符串。

一种直接创建：
String str = “Hello”;

字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中，new的不在池当中。

对于基本类型来说，“ == ” 是进行数值的比较
对于引用类型来说，“ == ” 是进行地址值的比较

作为面向对象的三大特征之一。
继承主要解决的问题就是：共性抽取
父类、子类
继承关系中的特点：
1.子类可以拥有父类的“内容”
2.子类还可以拥有自己专有的内容

在继承关系中，子类可以被当作父类看待。
定义一个父类的格式：

public class 父类名称{
	//....
}

定义一个子类的格式：

public class 子类名称 extends 父类名称(){
	//......
}

在父子类的继承关系中如果成员变量重名，则创建子类对象时，访问有两种方式：
1、直接通过子类对象访问成员变量：
通过谁创建的对象，就是谁的变量（等号左边是谁，就优先用谁）
2、间接通过成员方法访问成员变量：
该方法属于谁，就优先用谁，没有则向上找

对于子类来说：
局部变量： 直接写成员变量名
成员变量： this.成员变量名
父类的成员变量： super.成员变量名
例如；定义了一个父类Fu和一个子类Zi，在Demoextends类中实现。
在子类中：

public class Zi extends Fu {
    int num = 200;
    public void method1(){
        int num =300;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}

在Demoextends中建立子类对象zi，调用method1函数，得到如下输出：

在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的是谁的对象，就优先用谁，如果没有就想上找。

注意事项：
无论是成员变量还是成员方法，如果没有都是向上找父类，绝不会向下找子类的。

重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。

概念的区别：
重写（Override）：方法的名称一样，参数列表【也一样】
重载（Overload）：方法的名称一样，参数列表【不一样】

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

方法覆盖重写的注意事项：
1、必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。这个注释就算不写，只要满足要求，也是正确的方法覆盖重写。

2、子类方法的返回值（类型）必须【小于等于】父类方法的返回值范围。
提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

3、子类方法的权限必须大于等于父类方法的权限修饰符。
提示：public>protected>(default)不写>private
default是什么都不写，留空。

根据学习进度不断更新。。。。。