你必须掌握的JAVA基础知识

运算符

一 . 算数运算符

+	加法运算 ,字符串连接运算
-	减法运算
*	乘法运算
/	除法运算
%	取模运算 , 两个数字相除取余数
++ , –	自增自减运算

1.独立运算

前++和 后++没有区别 例如 ++i i++

2.混合运算

和其他变量放在一起 , 前++和 后++就产生了不同

int a = 1;
int b =++a; // b=2 , a=2 
int b=a++;  // b=1 , a=2
总结就是 : 只要有自增运算符, 那么自己肯定是增长的 , 就看是先赋值 , 还是后赋值了 

3.任何数据类型和字符串进行拼接的时候 , 结果都会变成字符串

System.out.println("5+5="+5+5);  //输出5+5=55

二 . 赋值运算符

=	等于号
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	取模等

赋值运算符 , 就是将符号左边的值 , 赋值给左边的变量

int i=5;
i+=5 
System.out.println(i);//i=10
计算方式 i=i+5   变量i先加5 ,再赋值变量i

三 . 比较运算符

==	比较符号两边数据是否相等 ,相等结果是true
<	比较符号左边的数据是否小于右边的数据 , 如果小于结果是true
>	比较符号左边的数据是否大于右边的数据 ,如果大于结果是true
<=	比较符号左边的数据是否小于或者等于右边的数据, 如果大于结果是false
>=	比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是false。
！=	不等于符号 ，如果符号两边的数据不相等，结果是true。

比较运算符 , 是两个数据之间进行比较的运算 , 运算的结果都是布尔值true 或者false

四 . 逻辑运算符

逻辑运算符包括
&&短路与	1.两边都是true,结果是true 2.一边是false ,结果是false 短路与特点 符号左边是false,右边不再运算
||短路或	1.两边都是false ,结果是false 2.一边是true , 结果是true 短路特点: 符号左边是true ,右边不再运算
! 取反	1. !true结果是false 2. !false结果是true

逻辑运算符 结果都是布尔值 true或者false

五 . 三元运算符

数据类型  变量名 = 布尔类型表达式 ? 结果1:结果2

结果是true 结果1赋值给变量

结果是false 结果2赋值给变量

int i = (1==2 ? 100 : 200);
System.out.println(i);//200

数据类型转换

1.自动转换

long num=100;

左边是long类型 , 右边是默认的int类型 , 左右不一样

int →long 符合了数据范围从小到大的要求, 所以发生了自动类型转换

2.强制类型转换

int num =(int)100L;

格式 : 范围小的类型 范围小的变量名 =(范围小的类型) 原本范围大的数据 ;

强烈注意: 浮点转换成整数 , 直接取消小数点, 可能造成数据损失精度 ;

if else 判断语句

第一种格式

if(关系表达式){
    语句体;
}

第二种格式 if…else

if(关系表达式){
  语句体1;  
}else{
  语句体2;   
}

第三种格式if…else if …else

if(判断条件1){
    执行语句1;
}else if(判断条件2){
    执行语句2;
} else if(判断条件N){
   执行语句n; 
}else {
   执行语句N+1;
}

switch选择语句

switch(表达式){
   case 常量值1:
   语句体1;
   breack;
   
   case 常量值2:
   语句体2;
   breack;
   
   default:
   语句体N+1;
   breack; 
}

case穿透性

在switch语句中 , 如果case的后面不写break , 将出现穿透现象 , 也就是不会再判断下一个case值 , 直接向后运行 , 直到遇到break ;

for循环语句

for(初始表达式;布尔表达式;步进表达式){
    循环体 ;
}

for循环的执行流程

for(初始化表达式1 ; 布尔表达式2; 步进表达式4 ){
    循环体3 ;
}
执行流程 :  1234→234→234 
也就是满足表达式 , 先执行循环体  ; 

while循环语句

while(布尔表达式){
    循环体
    步进表达式
}

do while 虚幻语句

do{
   System.out.println("无条件执行一次"); 
}while(false);

特点: 无条件执行一次 , 即使我们将循环条件直接写成false , 也依然会循环一次 ;

跳出语句 breack , continue

遇到break , 直接跳出去即可 ;

 public static void main(String[] args) {
        for(int i=1;i<10;i++){
            if (i==4){
                break;
            }
            System.out.println("我爱你");
        }
    }

遇到continue , 立即跳过当前的循环内容 , 马上开始下一次循环

public static void main(String[] args) {
    for(int i=1;i<10;i++){
        if (i==4){
            continue;
        }
        System.out.println("我爱你"+i);
    }
}
//就只是没有4

break 和continue 都是跳出本次循环 , 但是break是往后都不执行 , continue 是继续执行下边的内容

方法

首先这个方法没有参数 但是有返回值

返回值就是 产品

参数 就是 原料

当另一个方法调用这个方法的时候. 就相当于对这个产品进行加工 如果 这个工厂也有返回值的话

就把刚才加工的产品 当做自己的产品

后我们对他进行继承extends

成员变量和局部变量的区别

变量写在方法中 局部变量

变量写在类中 成员变量

成员方法的使用

public void eat(){
   System.out.println("正在吃饭");
}

成员方法就是不带有static的

成员变量以及成员方法的使用

对象 . 成员变量 成员变量不赋值的话 , 会有一个默认值 null 0

对象.成员方法()

另外不同包下想互相使用对象 , 就要先进行导包

构造方法

这是一个学生类的构造方法

public class Student {

    //创建一个构造方法
    public Student (){
        System.out.println("魔尊自己创建的构造方法");
    }
}

创建一个Demo类进行调用构造方法

public class DemoStudent {
    public static void main(String[] args) {
        //new 一个对象 就是在调用这个类的构造方法
        Student student = new Student();

    }
}

new 一个对象 , 就是在调用这个类的构造方法

注意事项 :

1.构造方法的名称必须和所在的类名完全一样 , 就连大小写也要一样

2.构造方法不要写返回值类型 , 连void都不写

3.构造方法不能return一个具体的返回值

4.如果没有编写任何构造方法 , 那么编译器将会默认赠送给你一个构造方法 , 没有参数 ,方法体什么事情都不做

5.一旦编写一个构造方法 , 那么编译器将不再赠送

6.构造方法也是可以进行重载的(意思是可以有多个构造方法)

重载就是方法名相同 , 参数列表不同

7.当你new对象的时候 , 带参数调用的就是有参构造方法 , 不带参数 , 调用的就是无参构造方法

this关键字

专门用来解决局部变量和类的成员变量重名的情况 this.变量 就是用的成员变量

public class Person {
   String name ="王健林";
   public void sayHello(String name){
       System.out.println(name+"你好,我是"+this.name);
   }
}

public class SayHello {
    public static void main(String[] args) {
        Person person = new Person();
        person.sayHello("王思冲");
    }
}

注意事项 :

当方法的局部变量和类的成员变量重名的时候 , 根据"就近原则" , 优先使用局部变量
如果需要访问本类当中的成员变量 , 需要使用格式 : this.成员变量
你就会发现 这个成员变量 和你方法中的this.成员变量 颜色都变成一样的紫色了
局部变量的前边什么都不要写
this.成员变量 =  对象 .成员变量  

private关键字

private关键字 和 get set方法结合使用  只有本类可以随便访问 , 其他类要通过get set 方法间接访问

person类这个方法中可以把年龄修改成任意数值 , 显然是不对的
然后我们把年龄修改成private
一旦使用了private进行修饰 , 那么本类当中仍然可以随意访问
但是 ! 超出了本类范围之外就不能再直接访问了 
那么就间接访问
间接访问private成员变量 , 就是定义一对Getter/Setter方法
必须叫setXXX 或者是getXXX命名规则
对于Getter来说 , 不能有参数, 返回值类型和成员变量对应
对于Setter来说 , 不能有返回值 , 参数类型和成员变量对应 

static关键字

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

staitc关键字修饰成员变量

当把成员变量用static修饰的时候 , 这样就new出来的对象都可以共享同一个值 , 当然你不想使用这个共用的值 ,你也可以自己来对他进行赋值

staitc关键字修饰成员方法

public class DemoStudent {
    public static void main(String[] args) {
        Student student = new Student();
        student.method();
        student.staticmethod(); //这是通过对象进行调用静态方法 , 正确但是不推荐
        Student.staticmethod(); //调用静态方法直接使用类进行调用即可
    }
}

另外静态不可以调用非静态

静态代码块

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

直接在一个类里面写一个static加一个{}

特点 : 当第一次用到本类时 ,静态代码块执行唯一的一次
静态代码块优先于构造方法执行
静态代码块的典型用途 :
用来一次性的对静态成员变量进行赋值

继承

继承主要解决的问题就是共性抽取 成员方法 成员变量都是可以继承的

在父子类的继承关系中 , 如果成员变量重名 , 则创建子类对象 , 访问有两种方式

直接通过子类对象访问成员变量 :

等号左边是谁 , 就优先使用谁 , 就看你左边创建使用的是什么类

间接通过成员方法访问成员变量 :

该方法属于谁 , 就调用谁的成员变量

1.当子类中成员变量 局部变量 父类中成员变量 都重名的时候 ?

public class FU {
    String num="父亲";
}

public class ZI extends FU{
    String num="儿子";
    public void method(){
        String num="孙子";
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);  //父类中用super
    }
}

public class Demo {
    public static void main(String[] args) {
        ZI zi = new ZI();
        zi.method();
    }
}

2.继承中子类成员方法 和父类成员方法重名 , 会访问谁呢 ?

规则 : 创建的对象是谁 , 就优先用谁 , 如果没有则向上找 就看new的是谁 , 就调用谁 !

重写与重载的区别

重写 : 方法名一样 , 参数列表一样

重载 : 方法名一样 , 参数列表不一样

public class FU {
  
public void method(){
    System.out.println("父类方法执行了");
}
}

public class ZI extends FU{
    @Override
    public void method1(){
        System.out.println("子类方法执行了");
    }
}

这个@Override就是用来检测子类是否正确进行了重写 , 如果不对则会报错 , 起到一个检测作用 , 不写也没事,

只需要在子类中进行书写即可

注意事项 :

子类方法的返回值必须[小于等于]父类方法的返回值范围 object类是最高类

子类方法的权限必须[大于等于]父类方法的返回值范围

其实这两点也不用考虑 百分之99都是一样的

Abstract

抽象方法 : 就是加上abstract关键字 , 然后去掉大括号 , 直接分号结束

抽象类 : 抽象方法所在的类 , 必须是抽象类才行 , 在class之前写上abstract即可

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

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("吃骨头");
    }
}

public class Demo {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}

如何使用抽象类和抽象方法 :

1.不能直接创建new抽象类对象

2.必须用一个子类来继承抽象父类

3.子类必须覆盖重写抽象父类当中所有的抽象方法 子类去掉抽象方法的abstract关键字 , 然后补上方法体大括号

4.创建子类对象进行使用

接口

接口的定义

public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
}

接口中包含的方法

java7 包含 : 1.常量   2. 抽象方法 
java8 包含 : 3.默认方法 4.静态方法 
java9 包含 : 5.私有方法

接口不可以直接使用 , 必须有一个实现类来实现该接口

接口中的抽象方法的使用

public interface Demointerface {
    
    public abstract void method();
}

注意事项:
1.接口当中的抽象方法 , 修饰符必须是两个固定的关键字 public abstract
2.这两个关键字修饰符 , 可以选择性的省略 . 

接口中默认方法的使用

public interface Demointerface {

    public abstract void method();

    public default void methodA(){
        System.out.println("这是一个默认方法");  
    }
}

这个默认方法 实现类不用进行重写也可以使用

接口中静态方法的使用

public static 返回值类型 方法名称 (参数列表){
    方法体
}

通过接口名称 , 直接调用其中的静态方法

接口名称 .静态方法名(参数);

接口中私有方法的使用

我们需要抽取一个共有的方法 , 用来解决两个默认方法之间重复代码的问题 , 但是这个共有方法不应该让实现类使用,应该是私有化的

私有方法刚好可以解决 java9新添加的

1.普通私有方法 : 解决多个默认方法之间重复代码问题

格式 :

private 返回值类型 方法名称 (参数列表) {
方法体
}

2.静态私有方法 , 解决多个静态方法之间重复代码问题

格式

 private static 返回值类型 方法名称 (参数列表){
    方法体    
 }

接口中成员变量的使用 :

接口中也可以定义成员变量 , 但是必须使用public static final 三个关键字进行修饰 , 从效果上看 ,其实就是常量

格式

public static final 数据类型 常量名称 =数据值 ;

一旦使用了final 关键字进行修饰 , 说明不可改变

注意事项 :

1.接口中的常量 ,可以省略public static final , 注意 ; 不写也照样是也可以的

2.接口当中的常量 必须进行赋值 , 不能不赋值

3.接口当总常量的名称 ,使用完全大写的字母 ,用下划线进行分割

在Java 9+版本中，接口的内容可以有：

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

继承父类并实现多个接口

1.接口是没有静态代码块或者构造方法的

2.一个类的直接父类是唯一的 , 但是一个类可以同时实现多个接口

3.如果实现类所实现的多个接口当中 , 存在重复的抽象方法 , 那么只需要覆盖重写一次即可

4.如果实现类没有覆盖重写所有接口当中的所有抽象方法 , 那么实现类就必须是一个抽象类

5.如果实现类实现的多个接口当中 , 存在重复的默认方法 , 那么实现类一定要对冲突的默认方法进行覆盖重写

6.一个类如果直接父类当中的方法 ,和接口当中的方法产生了冲突 , 优先使用父类当中的方法

类与接口之间的关系

1.类与类之间是单继承 其直接父类只能有一个

2.类与接口之间是多实现关系 可以实现多个接口

3.接口与接口之间是多继承关系

注意事项 :

1.多个父接口当中的抽象方法如果重复 , 没关系

2.多个父接口当中的默认方法如果重复 , 那么子接口必须进行默认方法的覆盖重写 ,而且必须带着default关键字

多态性

格式 一句话 左父右子 就是多态

父类名称 对象名 = new 子类对象();

接口名称 对象名 = new 实现类名称();

final

常见的四种用法

1.可以用来修饰一个类 该类不可以被继承

2.可以用来修饰一个方法 该方法不可以被重写

3.可以用来修饰一个局部变量 局部变量变成常量 , 不可以被改变

4.可以用来修饰一个成员变量 同样和上面的一样

权限修饰符

public>protected>(default）>private

内部类 : public /(default 也就是不写)

成员内部类 : pubic /protected /(default) /private

局部内部类 : 什么都不能写

内部类的使用

外部类名称 .内部类名称 对象名 =new 外部类名称() .new 内部类名称() ;

内部类的同名变量访问

public class Outter {
    int num=10;
    public class inner{

        int num=20;
        public void method(){
            int num=30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(Outter.this.num);
        }
    }
}

局部内部类的使用

局部内部类 ,只能在方法中使用 ,出了这个方法 就没法进行使用了

public class Outter {
    /*这是在创建一个局部内部类*/
    /*局部内部类 ,只能在方法中使用 ,出了这个方法 就没法进行使用了*/
    public void methodOut(){
        class Inner{
            int num =10 ;
            public void  methodIN(){
                System.out.println(num);
                System.out.println("韦德");
                System.out.println("詹姆斯");
                System.out.println("科比");
                System.out.println("博士");
            }
        }
        Inner inner=new Inner();
        inner.methodIN();

    }
}

public class Demo {
    public static void main(String[] args) {
        Outter outter=new Outter();
        outter.methodOut();
    }
}

匿名内部类

如果接口的实现类 (或者是父类的子类) 只需要使用唯一的一次 , 那么这种情况下就可以省略掉该类的定义 , 而改为使用[匿名内部类]

格式 :

接口名称  对象名 =new  接口名称 (){
//覆盖重写所有抽象方法
} ; 

public interface MyInterface {
    public abstract void method();
}

public class MyClass  {
    public static void main(String[] args) {
        MyInterface ms=new MyInterface() {
            @Override
            public void method() {
                System.out.println("这是一个匿名内部类");
            }
        };
        ms.method();
    }
}

好处 : 子类不需要实现接口 , 直接创建一个匿名内部类 , 然后对其进行调用方法即可

Objects非空判断

我们可以利用Objects中的方法来进行非空判断

Objects.requiredNonNull(obj);  我们可以利用这个方法来对参数进行非空判断
Objects.requiredNonNull(obj,"传递的对象的值是null");

异常

异常本身也是一个类 , 异常体系

throwable : Error  Exception  

这是Exception
try{
    //可能出现异常的代码
}catch(Exception e){
	//出现异常后执行的代码
   System.out.println(e); 
}

Error
OutofMemoryError:java heap space
内存溢出的错误 , 创建的数组太大了 ,超出了给JVM分配的内存

当出现错误的时候 , 你必须来修改你的代码 , 没有其他的途径可以解决

异常产生过程分析

首先JVM检测出程序会出现异常
JVM会做两件事 : 1.首先创建一个异常对象 , 这个异常对象包含了异常产生的(内容,原因,位置)
2.然后去寻找处理逻辑(try...catch) , 如果没有就继续抛给调用者

main方法接收到了这个异常对象 ,main方法也没有异常的处理逻辑,继续把对象抛给main方法的调用者JVM处理

JVM接收到了这个异常对象,做了两件事
1,把异常对象(内容, 原因,位置)以红色的字体打印在控制台上
2,JVM会终止当前正在执行的java程序       中断处理

JAVA异常处理的五个关键字

try catch finally   throw   throws

throw关键字

使用格式 : throw是在方法内部中使用的

throw new 异常类名(参数);

例如

throw new NullPointException("要访问的数组不存在");
throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在,已经超出范围");

throw关键字后边创建的是RuntimeException或者是其子类的对象,我们可以不处理,默认交给JVM处理(打印异常对象 ,中断程序)

throw关键字后边创建的是编译异常(写代码的时候报错) , 我们就必须处理这个异常,要么throws 要么try…catch

throws关键字 交给别人处理

throw关键字后边创建的是编译异常(写代码的时候报错) , 我们就必须处理这个异常,要么throws 要么try…catch

声明格式:

修饰符 返回值类型 方法名 (参数) throws 异常类名1 , 异常类名2 { }

try…catch 捕获异常

如果你是throws异常的话 , 遇到异常会立刻终止程序 ,所以我们得处理异常 :

语法 :

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

注意: 1. try 和catch 都不能单独使用, 必须连用

                2. catch 可以有多个

finally 代码块

finally: 在finally中存放的代码一定是会被执行的代码

finally代码示例 :

public class TryCatchDemo4 {
public static void main(String[] args) {
        try {
            read("a.txt");
        } catch (FileNotFoundException e) {
            //抓取到的是编译期异常  抛出去的是运行期 
            throw new RuntimeException(e);
        } finally {
            System.out.println("不管程序怎样，这里都将会被执行。");
        }
        System.out.println("over");
    }