Java基础知识梳理（万字解析）

数据类型

变量和常量

变量的命名规范

局部变量

类变量

实例变量

常量

运算符

java程序流程控制

Scanner类简单用法

方法

数组

面向对象Object-Oriented Programming（OOP）

类

对象

封装

继承 extends

多态

抽象 abstract

接口 interface

异常

异常分类

异常处理的方法：

案例

声明异常和抛出异常

案例

自定义异常

案例

数据类型

数据类型主要分为基本数据类型和引用数据类型两种。其中，基本数据类型分为数值类型和布尔类型。具体数据类型如下所示。

数据类型

注：String是类，不是关键字。 举例

private static String getType(Object a) {
        return a.getClass().toString();
}
public static void main(String[] args) {
    byte a=0;
    short b=1;
    int c=10;
    long d=20L;
    float e=10;
    double f=20.0;
    char g='a';
    boolean h=true;
    System.out.println(a+"===>"+getType(a)+"==="+Byte.SIZE);
    System.out.println(b+"===>"+getType(b)+"==="+Short.SIZE);
    System.out.println(c+"===>"+getType(c)+"==="+Integer.SIZE);
    System.out.println(d+"===>"+getType(d)+"==="+Long.SIZE);
    System.out.println(e+"===>"+getType(e)+"==="+Float.SIZE);
    System.out.println(f+"===>"+getType(f)+"==="+Double.SIZE);
    System.out.println(g+"===>"+getType(g)+"==="+Character.SIZE);
    System.out.println(h+"===>"+getType(h));
}

变量和常量

变量的命名规范

首字母小写，后面单词首字母大写见名知意
见名知意

局部变量

局部变量： 定义在方法中或者方法声明上的变量。 - 没有默认值 - 内存：存储在栈中的方法中 - 生命周期：随着方法的存在而存在，随方法消失而消失 - 作用域：方法外无法使用，只能在方法内使用

举例

pubilic void get(int a){
    //a,b都是局部变量
    int b=0;
}

类变量

类变量： 定义在类中方法外的变量。 - 有默认值 string 默认为null int默认为0 Boolean默认为false double默认为0.0 char默认为空格 - 内存位置：堆中的对象中 - 生命周期：随对象的存在而存在，随对象的消失而消失 - 作用域：在类中的方法都可以使用

举例

public class Person{
    //类变量/属性
    //可以使用private，设置为私有属性，无法在类外调用
    private int age;
    //public类型属性，可以在其他类中创建对象，并调用
    public String name;
    public double height;
    //类方法
    public void eat(){ }
}

实例变量

实例变量： 从属于对象。 - 默认值为0或者false 举例

public class Student{
    Person person=new Person();
    //无法调用
    System.out.println(person.age);
    //可以正常调用
    System.out.println(person.name);
}

常量

使用final定义
命名规范：大写字母加下划线

运算符

运算符类型	运算符
算术	+，-，*，/，%，++，--
赋值	=
关系	<,>,>=,<=,!=
逻辑	&&，\|\|，!
位	&，\|，^，~，>>,<<
条件	? : ---- x?y:z ---- x为true，返回y，反之，返回z
扩展	+=,-=

java程序流程控制

在这里插入图片描述

Scanner类简单用法

用户交互，需要使用Scanner类 - next() 读取到有效字符后结束有效字符之前遇到空白会自动去除必须先输入有效字符后才能用空白符作为分隔符或结束符不能得到带有空格的字符串 - hasNext() 用来查看next()的输入 - nextLine() 以Enter为结束，回车之前的所有字符都可以被获取可以获取空白符 - hasNextLine() 用来查看nextLine()的输入 - 直接输入特定类型的方法 nexInt() nexFloat() nexDouble() - Scanner输入类，属于IO流，使用完后需要关闭，以免占用资源 scanner.close();

方法

原子性：一个方法只完成一个功能，方便后期扩展。
Java是值传递，参数传递时传递的是值，不是地址。
方法重载同一个类中可以有相同名称的方法参数列表必须不同方法返回类型可以相同也可以不同
可变参数一个方法只能有一个可变参数可变参数必须为最后一个参数方法名(修饰符... 参数名称)
递归：尽量避免递归，防止栈溢出
static定义的方法，在类加载的时候就已经加载了

数组

//静态初始化
int[] a={1,2,3}
//动态初始化
int[] a=new int[10];
a[0]=1;

数组中的内容可以是任何数据类型，包括基本类型和引用类型
数组也是对象，数组元素等于对象的成员变量
稀疏数组：用于保存只有少数有用值的数组

在这里插入图片描述

数组排序（具体细节等有时间单写一篇文章）二分排序快速排序冒泡排序堆排序。。。等等

面向对象Object-Oriented Programming（OOP）

本质： 以类的方式组织代码，以对象的组织（封装）数据

类

类：一种抽象的数据类型，是某一类事物的整体描述。所有类默认继承object类

class 类名{
    类的属性
    类的方法
}

属性：事物的外在特征，人：姓名，年龄，性别等
方法：事物所具备的功能，人：吃，喝，睡等
构造方法
- 形式：
  - 和类名相同
  - 没有返回值
- 作用：
  - 创建对象
  - 用来给对象的属性进行初始化
  - 定义有参构造方法后，如果想要定义无参的对象，必须显示的定义一个无参的构造方法。

public class person{
    public int age;
    //构造方法--默认存在一个空的构造方法
    // Person p=new Person();
    // new本质上是在调用构造方法
    public person(){}

    //这也是构造方法但是需要给age赋值
    //新建对象时
    //Person p=new Person(18);
    public person(int age){
        this.age=age;
    }
}

类中的方法类型
- 静态方法
  - 类加载时就加载
  - 只加载一次
- 匿名方法
  - 创建对象时加载
- 非静态方法
  - 创建对象时加载
类是单继承的，但是接口可以多继承
一个java类中只能有一个public class类，但是可以有多个class 类
内部类：定义在类内部的类

public class person{
    public int age;
    public String name;
    public void eat(){}
    //内部类
    class Student{
        public int ID;
        public void learn(){}
    }
}

对象

对象： 是抽象概念的具体实例 - 对象能执行那些方法主要看左边的类型，和右边的new 关系不大

//创建一个Person对象
//这时会分配空间，进行默认初始化
//创建一个对象本质上是在调用构造方法
Person person=new Person();

匿名对象

创建：new 类名()
只能使用一次
匿名对象可以作为实际参数进行传递

封装

将属性私有
get/set ：使用快捷键alt+insert，设置所有数据的get/set方法
作用：
- 提高程序安全性，保护数据
- 隐藏代码的实现细节
- 统一接口
- 增加系统可维护性

继承 extends

本质是对某一批类的抽象
super
- 使用父类的非私有的属性或方法
- 调用父类的构造器必须在第一句
- 只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法

在这里插入图片描述

重写 @override
- 子类重写父类的方法
- 只能重写公有的方法
- 方法名要相同
- 参数列表要相同
- 修饰符可以扩大但不能缩小
  - public>protected>default>private
- 抛出的异常：范围可以缩小但不能扩大
- 重写的原因，父类的功能子类不一定需要或者满足

多态

可以实现动态编译
子类转换为父类，可能丢失一些自己的方法
多态是方法的多态，属性没有多态
- ClassCastException类型转换异常
- static方法属于类，不能重写
- private方法也不能重写
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用子类对象
instanceof
- X instanceof Y
- X和Y存在父子关系====true，反之=====False

public class Person {
}
public class Student extends Person {
}
public class Teacher extends Person {
}
public class Application {
    public static void main(String[] args) {
        //Object>Person>Student
        //Object>Person>Teacher
        //Object>String
        Object object=new Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("=================================");
        Person person=new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
//        System.out.println(person instanceof String);//编译报错
        System.out.println("=================================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
//        System.out.println(student instanceof Teacher);//编译报错
//        System.out.println(student instanceof String);//编译报错
    }
}

抽象 abstract

抽象类： abstract class 类名

public abstract class Person{}

不能创建抽象类的对象，只能靠子类来实现
抽象类中可以有抽象方法和普通方法

抽象方法： abstract 类型方法名

public abstract void run();

只有方法名，没有方法的实现
抽象方法只能在抽象类中

接口 interface

只有规范，无法自己写方法
接口都需要实现类，implements
- 实现类必须重写接口中的方法
接口中定义的方法都是抽象的
接口中的属性默认都是常量

异常

异常： 程序运行中出现的不正常现象，如果不能对这些现象进行正确处理可能导致程序不能运行，造成不必要的损失。

异常分类

Throwable： 可抛出的一切错误或者异常的父类 - Error：JVM，硬件，执行逻辑错误，不能手动处理 - Exception：程序再运行和配置中产生的问题，可处理 - 运行时异常：RuntimeException以及其子类 - 检查时异常：Exception以及其子类，RuntimeException除外

常见的异常如下图所示：

在这里插入图片描述

异常处理的方法：

可以使用多重catch捕获异常
- 捕获异常时，子类异常在前，父类异常在后
- 发生异常时按顺序逐个匹配，且只执行第一个与异常匹配的catch语句
try...finally...不捕获异常，将异常向上一级抛出
finally不执行的唯一情况是退出java虚拟机
finally可写可不写

在这里插入图片描述

案例

public class testException {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int re= 0;
        try {
            System.out.println("输入第一个数：");
            int n1=scanner.nextInt();
            System.out.println("输入第二个数：");
            int n2=scanner.nextInt();
            re = n1/n2;
        } catch (ArithmeticException e){
//            e.printStackTrace();
            System.out.println("算术异常发生了");
        } catch (InputMismatchException e){
//            e.printStackTrace();
            System.out.println("输入类型不匹配异常发生了");
        }catch (Exception e) {
//            e.printStackTrace();
            System.out.println("异常出现了");
        } finally {
            System.out.println("资源释放");
        }
        System.out.println("结果为："+re);
        System.out.println("程序结束了");
    }
}

运行结果：

正常执行时

出现异常时

声明异常和抛出异常

声明异常：

- 在方法名后添加throws关键字，并添加想要声明的异常类型

- 可以声明多个异常，用逗号隔开

案例

public class testExceptionThrows {
    public static void main(String[] args) {
        try {
            divide();
        } catch (Exception e) {
            System.out.println("异常发生");
        }
    }

    private static void divide() throws Exception,RuntimeException {//可声明多个异常，用逗号隔开
        Scanner scanner=new Scanner(System.in);
        int re= 0;
        System.out.println("输入第一个数：");
        int n1=scanner.nextInt();
        System.out.println("输入第二个数：");
        int n2=scanner.nextInt();
        re = n1/n2;
    }
}

运行结果

在这里插入图片描述

抛出异常： 根据代码的执行情况去抛出一个异常，可以结合自定义异常，准确抛出代码执行过程中可能出现的异常。

使用thorw关键字，在程序运行出现预期之外的数据时抛出异常
如果抛出的异常类型时Exception，需要在先声明异常或者使用try-catch处理异常

案例

public class testExceptionThrow {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入学生成绩：");
        int sorce=scanner.nextInt();
        //如果输入的学生成绩不符合正常情况就需要抛出异常
        if (sorce<0||sorce>100){
            //AgeException自定义异常
            throw new AgeException("输入成绩不符合规则");
        }else{
            System.out.println("该学生的成绩为："+sorce);
        }
    }
}

自定义异常

自定义异常的构造：

继承Exception或者其子类
添加构造方法

目的： 让抛出的异常名称更加准确，可以做的见文知意，从而提高项目维护和debug的效率

案例

Student类

public class Student {
    private String name;
    private int age;
    public Student(){}

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    //手动重写toString方法
    /*public String toString(){
        return name+":"+age;
    }*/

    //alt+insert自动重写toString方法
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

自定义异常：

public class AgeException extends RuntimeException {
    public AgeException() {
    }

    public AgeException(String message) {
        super(message);
    }

    public AgeException(String message, Throwable cause) {
        super(message, cause);
    }

    public AgeException(Throwable cause) {
        super(cause);
    }

    public AgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}