java基础

有参和无参
有返回值和无返回值
方法的注意事项：
1、方法应该定义在类中，但不能在方法中再定义方法，不能嵌套
2、方法定义的前后顺序无所谓
3、方法定义之后不会执行，如果希望执行，一定要进行调用，单独调用，打印调用，赋值调用
4、如果方法中有返回值，那么必须写上“return” 返回值，不能没有
5、return后边的返回值数据，必须和方法的返回值类型对应起来
6、对于void没有返回值的方法，不能写return后边的返回值，只能写return自己。
7、对于void方法中最后一行的return可以省略不写
8、一个方法中可以有多个return语句，但是必须保证同时只有一个会被执行到。
方法重载（overload）
1、方法名称相同，参数不同
2、参数的类型不同
3、参数的多类型顺序不同
方法重载与参数名称无关，与方法的返回值类型无关，与方法的修饰符无关。
数组
数组是一种容器，可以同时存放多个数据值
1、数组是一种引用数据类型
2、数组当中的多个数据，数据类型必须统一
3、数组的长度在程序运行期间不可改变
数组常见的初始化方式：
1、动态初始化（指定长度）
2、静态初始化（指定内容）
解析含义：
左侧数据类型：也就是数组当中保存的数据，全都是统一的什么类型
左侧的中括号：代表我是一个数组
左侧数组名称：给数组去一个名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度，也就是数组当中，到底可以保存到少个数据，是一个int数字
int[] a = new int[10] //动态初始化
int[] b = new int[]{10,20} //静态初始化，标准格式
int[] c = {10,20,30} //静态初始化，省略格式
静态初始化的省略格式不能拆成两个步骤
数组的使用
访问数组元素的格式：数组名称[索引值]
【注意】索引是从0开始的，一直到”数组长度-1“为止
使用动态数组初始化的时候，其中元素将会拥有一个默认值。

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相关
数组索引越界异常
空指针异常：
所有的引用类型变量，都可以赋值为一个null值，但代表其中什么都没有。
如果只赋值为null，没有进行new创建，那么将会发生空指针异常（nullPointerException）
数组的遍历：
遍历数组，将数组当中的每个元素挨个查找
数组元素的反转：

@Test
public void test02() {
    int[] array = {1, 343, 545, 232, 12, 1, 343, 43};
    for (int i = 0; i < array.length; i++) {
        System.out.println(array[i]);
    }
    System.out.println("--------------");
    for (int min = 0, max = array.length - 1; min < max; min++, max--) {
        int temp;
        temp = array[min];
        array[min] = array[max];
        array[max] = temp;
    }
    System.out.println(Arrays.stream(array).iterator());
}

**面向过程：**亲历亲为。
**面向对象：**只关心结果，不关心步骤。
面向谁就看重谁。
局部变量和成员变量：
1、定义的位置不一样：
局部变量：在方法的内部
成员变量：在方法的外部，直接写在类当中
2、作用范围不一样
局部变量：只在方法中才能使用，出了方法就不能在用
成员变量：整个类全都可以通用
3、默认值不一样
局部变量：没有默认值，如果想要使用，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样。
4、内存的位置不一样
局部变量：位于栈当中
成员变量：位于堆当中
5、生命周期不一样
局部变量：生命周期短，和方法生命周期相同
成员变量：生命周期长。和类生命周期相同

 public static List<Object> list;
    @Test
    public void test01(){
//        List list; //输出的时候直接报错
        System.out.println(list);//null
    }

面向对象的三大特征
封装、继承、多态
封装性在java当中的体现：
方法就是一种封装
关键字private也是一种封装
封装就是将一些信息隐藏起来，对于外界不可见。
this关键字的作用：
当方法的局部变量和类当中的成员变量重名的时候，根据”就近原则“，有限使用局部变量。
如果需要访问类当中的成员变量，则需要使用格式：this.成员变量名
”通过谁调用的方法，谁就是this“
构造方法：
1、构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
2、构造方法不要写返回值类型，连void都不能写
3、构造方法不能return一个具体的返回值
4、如果没有编写任何构造方法，那么编译器会自动赠送一个构造方法，方法体什么事情都不做
5、一旦编写至少一个构造方法，那么编译器将不再赠送。
格式：

class AAA{
    public AAA(){
        System.out.println("这是构造方法");
    }
}

标准的类：
1、所有的成员变量都要使用private关键字修饰
2、为每一个成员变量生成一对getter/setter方法
3、编写一个无参数的构造方法
4、编写一个全参数的构造方法

API概述和使用步骤：
API（Application Programming interface）：应用程序变成接口
java API是一个程序方法的字典，时jdk中提供给我们使用的说明文档。
API使用步骤：
1、打开帮助文档
2、点击显示，找到索引，看到输入框
3、你找谁？在输入框里输入，然后回车。
4、看包。java.lang下的类是不需要导包的，其他需要。
5、看类的解释和说明。
6、学习构造方法。
7、使用成员方法。

Scanner的使用
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); //System.in表示从键盘输入
int i = sc.nextInt();
System.out.println(i);
}

匿名对象：
匿名对象只能被使用一次
Random的使用：
Random random = new Random();
random.next();
static关键字
static可以修饰静态变量，修饰之后就是共享变量
static可以修饰方法，修饰之后就是静态方法，是属于类的，直接通过 类名.静态方法名() 直接调用
一旦使用static修饰成员变量，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用。
静态不能直接访问非静态。
静态方法中不能使用this关键字。
【注意】根据类名称访问静态成员变量的时候，全程和对象就没有关系，只和类有关系。
静态代码块
static {
代码块;

}
【特点】：当第一次用到本类时，静态代码块执行唯一的一次。静态内容总是优先于非静态，所以静态代码块比构造方法先执行。
静态代码块的典型用途：
用来一次性地对静态成员变量进行赋值。
Arrays数组工具类
Math数学工具类
double obs(double num) //获取绝对值
double ceil(double num) //向下取整
double frool(double num) // 向下取整
double round(double num) //四舍五入
继承
直接通过子类访问成员变量
等号左边是谁，就优先用谁，没有则向上找
间接通过成员方法访问成员变量
该方法属于谁，就优先用谁，没有则向上找
public class Fu {
int num =10;
}
class Zi extends Fu{
int num =20;
public void method(){
int num = 30;
System.out.println(num);//方法num
System.out.println(this.num);//本类中的num
System.out.println(super.num);//父类中的num
}

}
方法重写（override）
在继承关系当中，方法名称相同，参数列表也一样
子类方法的返回值必须小宇等于父类方法的返回值范围
子类方法的权限必须大于等于父类方法的权限修饰符
父子类当中构造方法的访问特点
子类构造方法中有一个默认隐含的super()调用，所以一点先调用父类构造，后执行子类构造
子类构造可以通过super关键字来调用父类重载构造
super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造。
super只能有一个，而且还必须是第一个
this的使用
public class Fu {
int num =10;
}
class Zi extends Fu{
Zi(){
this(100); //调用本类中的另一个构造函数
}
Zi(int num){
this.num = num;
}
int num =20;
public void method(){
int num = 30;
System.out.println(num);//方法num
System.out.println(this.num);//本类中的num
System.out.println(super.num);//父类中的num
Zi zi = new Zi();
}
}
继承的三大特征：
java语言是单继承的。一个类的直接父类只能有唯一一个。java可以多级继承。
抽象方法和抽象类的使用
1、不能直接创建new一个抽象类对象
2、必须用一个子类来继承抽象父类
3、子类必须覆盖重写抽象父类中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体的大括号。

public abstract class AAA {
    public abstract void eat();
}

class BBB extends AAA{

    @Override
    public void eat() {
        
    }
}

注意事项
1、抽象类不能创建对象
2、抽象类中可以有构造方法，是供子类创建对象时，初始化父类成员使用的。【理解：子类的构造方法中，有默认的super()，需要访问父类的构造方法】
3、抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类
4、抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错，除非该子类也是抽象类。
接口
接口就是一种公共的规范标准

interface CCC{
    public abstract void method();
}

java8
1、常量 （public static final）三个连用
2、抽象方法 默认前边（public abstract）
3、默认方法 （public default）
4、静态方法 （public static）
java9：
私有方法 （private）

接口使用步骤：
1、接口不能直接使用，必须有实现类来 实现接口
2、接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。

java9+版本中，接口的内容可以有：
1、成员变量其实是常量，格式：
[public] [static] [final] 数据类型 常量名称 = 数据值；
【注意】：常量必须进行赋值，而且一旦赋值不可改变。常量名称完全大写，多个单词用下划线分隔。
2、接口中最重要的就是抽象方法，格式：
[public] [abstract] 返回值类型 名称方法（参数列表）；
【注意】：实现类必须覆盖重写接口中所有的方法，除非实现类是抽象类。
3、从java8开始，接口中允许定义默认方法，格式：
[public] default 返回值类型 方法名称（参数列表） {方法体}
【注意】：默认方法也可以被覆盖重写
4、从java8开始，接口里允许定义静态方法，格式：
[public] static 返回值类型 方法名称（参数列表）{方法体}
【注意】：应该通过接口名称进行调用，不能通过实现类对象调用接口静态方法。
5、从java9开始，接口里允许定义私有方法，格式：
普通私有方法：private 返回值类型 方法名称（参数列表）{方法体}
静态私有方法：private static 返回值类型 方法名称 （参数列表）{方法体}
【注意】：private的方法只有接口自己才能调用，不能被实现类或别人使用。

使用接口时要注意的：
1、接口是没有静态代码块或者构造方法的
2、一个类的直接父类是唯一的，但是一个类可以同时实现多个接口
3、如果实现类所实现的的多个接口中，存在重复的抽象方法，那么只需要覆盖重写一次即可
4、如果实现类没有覆盖重写接口中的抽象方法，那么实现类就必须是一个抽象类
5、如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6、一个类如果直接父类当中的方法，和接口当中的默认方法产生冲突，优先用父类当中的方法。

多态的格式与使用：
代码中多态的体现：父类引用指向子类对象
访问成员变量的两种方式：
1、直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找；
2、间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找；

public  class AAA {
    int num = 10;
    public void eat(){
        System.out.println("成员方法访问成员变量："+num);
    };
}

class BBB extends AAA{
    int num = 20;
    @Override
    public void eat() {
        System.out.println("子类重写父类方法："+num);
    }
}

class CCC{
    public static void main(String[] args) {
        AAA obj = new BBB();
        System.out.println("通过对象对象名直接访问成员变量："+obj.num);

        System.out.println("=====================");
        obj.eat();
    }
}

在多态的代码当中，成员方法的访问规则是：
看new的是谁，就优先用谁，没有则向上找
【口诀】：编译看左，运行看右
对比一下：
成员变量：编译看左边，运行还看左边
成员方法：编译看左，运行看右边
对象的向上/向下转型
1、对象的向上转型，其实就是多态写法：
格式：父类名称 对象名 = new 子类名称();
含义：右侧创建一个子类对象，把它当作父类来看待使用。
【注意事项】：向上转型一定是安全的，从小范围转向了大范围。
对象的向下转型，其实就是一个【还原动作】:
格式：子类名称 对象名 =（子类名称） 父类对象。
含义：将父类对象，[还原]成为本来的子类对象。
【注意事项】：
1、必须保证对象本来创建的时候，就是猫，才能向下转型成为猫。
2、如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。
final关键字：
常见四种用法：
1、可以修饰一个类
2、可以用来修饰一个方法
3、还可以用来修饰一个局部变量
4、还可以用来修饰一个成员变量
final修饰成员变量：
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不可变的。
1、如果成员变量有默认值，所以用final之后必须手动赋值，不会再给默认值了。
2、对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值，二者选其一。
3、必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。

内部类的概念与分类：
【注意】：内用外，随意访问；外用内，需要内部对象
使用成员内部类的两种方式：
1、间接方式：再外部类的方法当中，使用内部类，然后main只是调用外部类的方法。
2、直接访问，公式：【外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();】

public  class AAA {
    int num = 100;
    int age = 20;
    class BBB{
        int num =200;

    }
}
class CCC{
    public static void main(String[] args) {
        int num = 30
        AAA.BBB bbb = new AAA().new BBB(); //内部类创建方法
         System.out.println(num); //内部类局部变量
        System.out.println(this.num); //内部类成员变量
        System.out.println(AAA.this.num); //外部类成员变量
    }
}

局部内部类定义：
如果一个类定义在一个方法内部的，那么这就是一个局部内部类。
“局部” ：之哟当前所属的方法才能使用它，出这个方法外边就不能用了。
class AAA{
//局部内部类
public void method(){
class BBB{
private String name;
}

}

}
类的权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰付规则：
1、外部类：public 、（default）
2、成员内部类：public 、protect、default、private
3、局部内部类：什么都不能写

局部内部类final问题：
局部内部类，如果希望访问所在的局部变量，那么这个局部变量必须是【有效final的】
【备注】：从java 8开始，只要局部变量事时不变，那么final关键字可以省略。
原因：
1、new出来的对象是在堆内存当中。
2、局部变量是跟着方法走的，在栈内存当中。
3、方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4、但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。
匿名内部类：
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么这种情况下就可以省略掉该类的定义，而改为使用【匿名内部类】。
匿名内部类的定义格式：
接口名称 对象名 = new 接口名称(){
//覆写重写所有抽象方法
}
随机抢红包：

日期时间类：
P220-P227

System类：
public static lang currentTimeMillis() //获取当前时间的毫秒值。
public static void arrpycopy(Object src，int srcPos，Object dest ，int desPos，int length); //将数组中指定的数据拷贝到另一个数组当中
String，StringBuild，StringBuffer：
string类：字符串是常量；它们的值在创建之后不能更改。字符串的底层是一个被final修饰的数组，不能改变，是一个常量。
stringbuild类：字符串缓冲区，可以提高字符串的操作效率（堪称一个长度可以变化的字符串），底层也是一个数组，但是没有被final修饰，可以改变长度。
stringbuffer类：安全的。
Collection集合
集合概述：
集合：集合是java中提供的一种容器，可以用来存储多个数据。
集合和数组都是容器，有啥区别呢？
数组的长度是固定的，集合的长度是可变的。
数组中存储的是同一类型的元素，可以存储基本数据类型值。集合存储的都是对象。而且对象的类型可以不一致。在开发中一般当对象多的时候，可以使用集合进行存储。
集合框架：
集合按照存储结构可以分为两大类：分别是单列集合（java.util.Collection）和双列集合（java.util.Map）。

P-240-P270
红黑树：
约束：
1、节点可以是红色或者黑色；
2、根节点是黑色的；
3、叶子节点（空节点）是黑色的
4、每个红色的节点的子节点都是黑色的；
5、任何一个节点到每个叶子节点的所有路径上黑色节点数相同

多线程：（P302）
并发：指两个或多个事件在同一个事件段内发生
并行：指两个或多个事件在同一时刻发生（同时发生）
线程与进程：
进程：指一个内存中运行的应用程序
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程
线程调度：
分时调度：
所有线程轮流使用cpu的使用权，平均分配每个线程占用cpu的时间。
抢占调度：
优先让等级高的使用cpu，如果线程的优先级相同，那么会随机选择一个（线程随机性），java使用的为抢占式调度。
创建线程类：
java执行main方法，main方法会进入到内存，jvm会找操作系统开辟一条main方法通向cpu的执行路径，cpu就可以通过这个路径来执行main方法，而这个路经有一个名字，叫main（主）线程。
创建多线程的第一种方式：
实现步骤：
1、创建一个Thread类的子类：
2、在Thread类的子类中重写Thread类中的run方法，设置线程任务（开启线程要叫做什么？）
3、创建thread类的子类对象
4、调用thread类中的方法start()方法，开启新的线程，执行run方法。
void start（）使该线程开始执行，java虚拟机调用线程的run方法。结果是两个线程并发地运行，当前线程（main）线程和另外一个线程（创建地新线程，执行其run方法）。多次启动一个线程是非法地，特别是当线程已经结束后，不能再重新启动。
java程序属于抢占式调度，哪个线程地优先级高，那个线程优先执行，同一个优先等级，随机选择一个执行。

jvm执行main方法，找os开辟一条main方法通向cpu地路径，这个路径叫main线程，主线程cpu通过这个线程，这个路径可以执行main方法

对于cpu而言，就有了两条执行的路径，cpu就有了选择的权力，cpu喜欢谁，就会执行哪条路径，我们控制不了cpu，所以就有了程序的随机打印结果

获取线程名称的方法：
public static void main(String[] args) {
Thread thread = new Thread();
thread.getName();//获取线程名称
String name = Thread.currentThread().getName();//获取当前线程的名称
}
public static void sleep（long millis）：使当前正在执行的线程以指定的毫秒数暂停（暂停时停止执行），毫秒结束之后，线程继续执行

创建多线程程序的第二种方式：实现runnable接口
java.lang.runnable
runnable接口应该由哪些打算通过某一线程执行其实例的类来实现，类必须定义一个称为run的无参数方法。
java.lang.Thread类的构造方法
Thread（Runnable target）分配新的Thread对象
Thread（Runnable target，String name）分配新的Thread对象。

实现步骤：
1、创建一个runnable接口实现类
2、再实现类中重写Runnable接口的run方法，设置线程任务
3、创建一个Runnable接口的实现对象
4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
5、调用Thread类中的start方法，开启新的线程执行run方法。