1、Java基础知识

一、Java基础

第1阶段：Java基本语法

1、变量与运算符

八大基本数据类型？

整型：byte short int long

浮点型：float double

字符型：char

布尔型：boolean

2、流程控制语句

if-else   switch   

while   do-while 

3、数组

第2阶段：Java面向对象编程

1、成员变量和局部变量

a.定义位置不同:

成员:类中方法外

局部:方法中或者参数位置

b.初始化值不同

成员:有默认值

局部:没有默认值

c.作用范围不同

成员:作用于整个类

局部:只作用于方法内部

d.内存位置不同

成员:在堆中,跟着对象走

局部:在栈中,跟着方法走

e.生命周期不同

成员:随着对象的创建而创建,随着对象的消失而消失

局部:随着方法的调用而产生,随着方法的调用完毕而消失

静态成员&私有成员

静态成员：生命周期和类一样，属于类成员，不属于某个对象，类名直接调用

私有成员：外界不可以直接调用，对外提供get、set方法、构造方法赋值

2、面向对象的三大特性？展开说说

（1）、封装：隐藏内部细节，对外提供接口

（2）、继承：子类继承父类,可以直接使用父类中非私有成员,子类不用写重复性代码，extends关键字

成员变量访问特点:看等号左边是谁,先调用谁中的成员变量，子类没有找父类

成员方法访问特点:看new的是谁,先调用谁中的方法，子类没有找父类

注意：子类重写父类方法之后,权限必须要保证大于等于父类权限(权限指的是访问权限)

public -> protected -> 默认 -> private

继承中构造方法的特点

1.注意:new子类对象时,会先初始化父类(先走父类无参构造方法)

2.原因:每个构造方法的第一行,默认都会有一个super(),不写jvm自动提供一个，super()代表的是父类无参构造

3.注意:不管是super还是this,只要在构造中使用,都必须在第一行,所以二者不能同时手写出来

 

（3）、多态：继承、重写

多态前提下,不能直接调用子类特有成员

new对象:父类引用指向子类对象

Fu fu = new Zi();

//多态形式new对象
Animal animal = new Dog();
animal.eat();//重写的 animal接收的是dog对象,所以调用的是dog中的eat
//animal.lookDoor();   多态前提下,不能直接调用子类特有成员

看new的是谁,先调用谁中的成员方法,子类没有,找父类

优点：扩展性强

public static void method(Animal animal){//Animal animal = dog   Animal animal = cat
    animal.eat();
}

向上转型
父类引用指向子类对象  Fu fu = new Zi();
向下转型
向下转型:好比强转,将大类型强制转成小类型

3、接口与抽象类的区别

抽象类可以只有普通方法或者抽象方法；子类继承父类之后,需要重写父类中所有的抽象方法,不然编译报错；抽象类中可以有成员变量,构造,成员方法，有构造方法,是供子类创建对象时,初始化父类属性使用的

接口的方法都没有方法体

jdk8:

默认方法:public default 返回值类型 方法名(形参){}

静态方法:public static 返回值类型 方法名(形参){}

jdk9开始:

私有方法:

private的方法

相同点:
  a.都不能new
  b.都包含抽象方法,其子类或者实现类都必须重写这些抽象方法
      
不同点:
  a.抽象类:一般作为父类使用,可以有成员变量,构造,成员方法,抽象方法等
  b.接口:成员单一,一般抽取接口,抽取的都是方法,视为功能的大集合
  c.类不能多继承,但是接口可以

4、重载与重写的区别

重写是子类重写父类方法，用override关键字

重载是方法名字相同，参数个数、顺序、类型不同，与返回值和访问修饰符没有关系

第3阶段：Java高级应用

异常处理

1、编译时异常
a.编译时报错
b.处理方法：
try-catch：显式捕获异常并处理
throws：抛出异常，让方法的调用者负责处理
c.Exception的子类中，除了RuntimeException及其子类之外，其他都属于编译时异常
2、运行时异常
a.程序运行期间由JVM抛出的异常
b.常见类型：
NullPointerException（空指针异常）
IndexOutOfBoundsException（索引越界异常）
c.运行时异常是由程序逻辑错误导致的

多线程

一、创建线程的几种方式
继承Thread类
实现runnable接口
实现callable接口
线程池
tips：
yield():礼让线程
join():插队线程
二、线程的状态
新建、运行、阻塞、终止、等待
三、线程池
七大参数
核心线程、最大线程、空闲时间、单位、线程工厂、拒绝策略、任务队列

常用类和基础API

String
一、实现原理
a.底层是被final修饰的byte数组 private final byte[] value;
[value的引用地址不可变，但是value数组里面的数据元素其实是可变的。value的引用地址会分配在栈中 ，而其对应的数据是在常量池中保存的，常量池中数组本身的数据元素可变]
b.String类用final关键字修饰，说明String不可被继承
二、String的方法
1.判断方法
boolean equals(String s) -> 比较字符串内容
2.获取功能
int length() -> 获取字符串长度
String concat(String s)-> 字符串拼接,返回新串儿
char charAt(int index) -> 根据索引获取对应的字符
int indexOf(String s) -> 获取指定字符串在大字符串中第一次出现的索引位置
String subString(int beginIndex) -> 截取字符串,从指定索引开始截取到最后,返回新串儿
3.转换功能
String replace(CharSequence c1,CharSequence c2)-> 替换字符
                 CharSequence->String的接口
4.分割功能
String[] split(String regex)->按照指定的规则分割字符串
  注意:regex写的是正则表达式 -> . 在正则表达式中代表任意一个字符
5.其它
String trim() -> 去掉字符串两端空格
boolean contains(String s) -> 判断老串儿中是否包含指定的串儿
boolean endsWith(String s) -> 判断老串儿是否以指定的串儿结尾
boolean startsWith(String s) -> 判断老串儿是否以指定的串儿开头
String toLowerCase()-> 将字母转成小写
String toUpperCase() -> 将字母转成大写
三、String、StringBuffer、StringBuilder
String:拼接字符串效率低,每拼接一次,都会产生一个新的字符串对象,耗费内存资源
StringBuilder,底层自带一个缓冲区(没有被final修饰的byte数组)拼接字符串之后都会在此缓冲区中保存,在拼接的过程中,不会随意产生新对象,节省内存
StringBuffer:效率比较低,线程安全
StringBuilder:拼接效率比StringBuffer高、线程不安全
补充：
StringBuilder append(任意类型数据) -> 字符串拼接,返回的是StringBuilder自己
StringBuilder reverse()-> 字符串翻转,返回的是StringBuilder自己
String toString() -> 将StringBuilder转成String-> 用StringBuilder拼接字符串是为了效率,为了不占内存,那么拼完之后我们后续可能会对拼接好的字符串进行处理,就需要调用String中的方法,所以需要将StringBuilder转成String 
四、装箱&拆箱

集合框架

 

泛型

数据结构与集合源码

File类与IO流

网络编程

反射机制

JDK8-17新特性

算法：

1、二分查找

public int binary(int[] arr,int target){

    int left=0;
    int right=arr.length-1;
    int mid; 
    while(left<=right){
        mid=(left+right)/2;
        if(target<arr[mid])
        {
            right=mid-1;
        }else if(target>arr[mid]{
            left=mid+1;
        }else{
            return mid;
        }
    }
    return -1;

}

二、冒泡排序

public void sort(int[] arr)
{
    for (int j = 0; j < arr.length-1; j++) {
            /*
              内层循环代表每一圈比较的次数
              每圈都少比较一次
             */
            for (int i = 0; i < arr.length-1-j; i++) {
                if (arr[i]>arr[i+1]){
                    int temp = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }
}