Java的基础知识-CSDN博客

本文链接：https://blog.csdn.net/u010019566/article/details/99582943

这篇博客是对Java基础知识的总结，涵盖Java基本语法、字符串处理、面向对象特性、集合框架、异常处理和多线程等内容。文章详细讲解了Java的八大基本数据类型、String与StringBuffer/StringBuilder的区别、封装、继承、多态的概念，以及ArrayList与Array的区别。同时，讨论了构造器、this与super的使用，接口与抽象类，并概述了集合中的Collection和Map接口及其常见实现类。此外，还介绍了异常处理的基本概念和线程的生命周期。

摘要由CSDN通过智能技术生成

Java基础知识（第一部分）

在初学Java的过程中，一直在漫无目的看书写代码，最近一段时间，想把以前的内容回过头来总结一遍，温故而知新，也是对Java基础知识再次学习。

一、总体架构

以书籍的目录为例，市场上大多数的Java书籍从两部分来阐述Java的内容，第一部分则是Java的基础知识，而第二部分则是Java的深入部分。今天就将Java的基础部分进行一个简单的总结。首先，它的大体框架如下：

（1）Java基本语法（基本数据类型、数组的建立）

（2）字符串（String、StringBuffer、StringBuilder）

（3）面向对象之三国鼎立（封装、继承、多态）(Java的核心）

（4）面向对象之群雄争霸

（5）集合的楚汉争霸（Collection、Map）

（6）异常（Throwable）

（7）多线程（Thread、Runnable）

二、内容讲解

（1）Java基本语法

（1.1）基本数据类型

Java有八大基本数据类型，分别是字节、短整型、整型、长整型、字符型、浮点型、双精度型、布尔型

基本数据类型	字节	取值范围
byte	1	-2^7 - 2^7-1
short	2	-2^15 ~ 2^15-1
int	4	-2^31 ~ 2^31-1
long	8	-2^63 ~ 2^63-1
char	2
float	4
double	8
boolean	4	true、false

（1.2）数组的建立

基本数据类型[] 数据名 = new 基本数据类型[定义数组的长度]
以整型数据为例，创建数组从语法上来说两步走
	（1）定义个数组的引用变量
	（2）将创建的数组赋给这个引用变量，也就是这个引用指向它

int[] arr;
arr = new int[10];
//合起来就是
int[] arr = new int[10];
//此时初始化数据

由于传统建立的数据需要初步定义好数组的长度，因此创建数组长度过小则会不够保存数据，而数组长度过大则会导致浪费资源的现象，因此动态数组ArrayList则比传统数组更有优势，这一点会在集合部分进行介绍。除此之外，字符串String.toCharArray()也能够转换为字符数组，这个方法在很多编程题中用到，因此，贴上此方法的源码：

public char[] toCharArray() {
   
        return this.isLatin1() ? StringLatin1.toChars(this.value) : StringUTF16.toChars(this.value);
    }

（2）字符串

（2.1）String

线程安全不可变的字符串

String类包含许多方法使用String类最大特性是不可变性，因此要使用String.split()时要赋予新的String对象。
String.toCharArray()将String对象转换为字符数组

	public static void main(String[] args) {
   
        String str="abcde";
        char[] ch = str.toCharArray(); //ch{a,b,c,d,e}
    }

String.charAt(int index)方法，获取字符串的单个字符
String.valueOf(int i)，获取int型的字符串
String.length()，获取字符串的长度

（2.2）StringBuffer

线程安全可变的字符串，效率低于StringBuilder

append()方法，写入数据
charAt()返回指定索引的数据
reverse，字符串翻转
toString，返回字符串

（2.3）StringBuider

线程不安全的可变字符串，但是效率高于StringBuffer，其使用方法与StringBuffer一样

append()方法，写入数据
charAt()返回指定索引的数据
reverse，字符串翻转
toString，返回字符串

（3）面向对象之三国鼎立

在面试的过程中，很多面试官会首先问Java面向对象的特点是什么？（答：封装、继承和多态）那你回答一下什么是封装、继承和多态，以及它们的使用场景？（答：…）

（3.1）封装

Java提供了四个修饰符来保护Java类中的成员变量、方法不受外界所破坏，这四个访问修饰符如下所示：

访问修饰符	访问权限
public	全局范围
protected	子类及同一包的类
默认(空)	同一包中的类
private	同一个类中

一般来说，使用private来封装类中的成员变量的时候，这个成员只能在当前类的内部被访问，该类会提供set、get方法来供其它类进行调用。

//用户类
public class User {
   
    private String name;
    private int id;

    public String getName() {
   
        return name;
    }

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

    public int getId() {
   
        return id;
    }

    public void setId(int id) {
   
        this.id = id;
    }
}
//----------------------------------------------
//学生类
public class Student {
   
    public String name;
    public int id;
}
//测试类
public class Test {
   
    public static void main(String[] args) {
   
        User user = new User();
        Student student = new Student();
        String name = student.name;
        String uname = user.name;//这行会报错，因为User类的name变量是私有的。外部类无法访问
         //以下是正确的调用
        user.setName("张三");
        System.out.println(user.getName());
    }
}

（3.2）继承

Java只能单继承，其继承关键字为extends

public class Student {
   
    public String name;
    public int id;
    
    public void sayHello(){
   
        System.out.println("Hello");
    }
}

public class StudentChild extends Student {
   

    public void sayHelloAlso(){
   
        super.sayHello();
        System.out.println(super.name);
        System.out.println(super.id);
    }

    @Override
    public void sayHello(){
   
        System.out.println("GoodBye");
    }
    public static void main(String[] args) {
   
        StudentChild studentChild = new StudentChild();
        studentChild.sayHelloAlso();
        studentChild.sayHello();
    }
}
//输出
Hello
null
0
GoodBye

总结：子类继承父类能够得到父类的成员变量和方法，子类中的方法可以用关键字super.成员变量或方法来得到父类的成员变量或方法，当父类的方法不满足子类的需求时，子类可以重写父类的方法，方法重写（Override）需要满足“两同两小一大”原则。

两同：方法名与参数列表都相同
两小：返回值类型、抛出的异常
一大：访问权限类型

（3.2）多态

首先介绍一下Java引用变量的类型，其包括编译时的类型和引用时的类型。

编译时类型：由声明变量时使用的类型所决定
运行时类型：实际赋给该变量的对象所决定

多态的场景：当编译时类型与运行时类型不一致时，此时就会发生多态情况。例如，下面程序的
Student s1 = new StudentChild(); 子类和父类都包含sayHello()方法，当s1调用sayHello方法时，会运行子类的sayHello方法。父类的引用变量指向子类的对象。
相同类型的变量、调用同一个方法时呈现出多种不同的行为特征，这就是多态。
总结：编译看左边，运行看右边，运行一个Java程序的时候，javac会首先编译.java程序为 .class文件，当编译的时候识别出左边的变量是否包含该变量所调用的方法，若包含该方法，则编译通过，Jvm会将编译的.class文件进行加载给机器能够识别的语言；反之，编译失败，则JVM无法识别出.class文件。

public class Student {
   
    public String name;
    public int id;

    public void sayHello(){
   
        System.out.println("Hello");
    }
    public void noByeBye(){
   
        System.out.println("Bye");
    }
}

public class StudentChild extends Student {
   

    public void sayHelloAlso