Java基础教程（五千字带你快速入门！）

目录

一. Java语言介绍

二. Java的基本语法

1. Java的数据类型

2. 基本数据类型转换

3. 循环结构

三. 数组

📖Arrays类

四. 面向对象

1. 类(Class)

2. 对象(Object)

3. 特征—封装

4. 特征—继承

5. 特征—多态

---

一. Java语言介绍

---

1. Java语言的特点：

○ 开源           ○ 简单易学        ○ 平台无关性        ○ 面向对象

○ 支持网络    ○ 多线程机制    ○ 动态内存管理机制（只需申请内存空间，何时释放不用管）

○ 安全           ○ 生态丰富        ○ 高性能

2. Java语言的运行机制：

•  开发一个 .java文件 (源文件)

•  使用java编译器将 .java文件编译为标准统一的 .class文件（字节码文件）

•  把编译后的 .class文件交给对应平台的虚拟运行即可

 3. Java语言如何实现跨平台？

在不同操作系统上安装不同java虚拟机；在window（开发），Linux（运行），mac上安装不同虚拟机只需开发一次，就可在不同操作系统上运行；相当于一次编写，到处执行。

4. 什么是虚拟机？

JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一个虚构出来的计算机环境，是通过在实际的计算机上仿真模拟各种计算机功能来实现的,因为有了不同的JVM，所以同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性,也称为Java具有良好的可移植性, 但是前提是要具有不同的JVM。

5. 了解JDK,JRE,JVM三者之间的关系：

○ JDK(Java Development Kit Java开发工具包)

JDK是提供给Java开发人员使用的，其中包含了java的各种编译工具，打包工具等，也包括了JRE.

○ JRE(Java Runtime Environment Java运行环境)

JRE中包括 java程序运行所需要的核心类库,也包含Java虚拟机.

○ JVM(Java Virtual Machine Java虚拟机)

JVM是最终运行 java程序的核心环境

二. Java的基本语法

---

1. Java的数据类型

✎. java的数据类型分为基本数据类型 和引用数据类型 两种.

基本类型有8种：

📖关于引用数据类型：

•  引用类型是面向对象编程中的一个重要概念，它表示的是对实际对象的引用，而不是直接存储对象的数据。

•  引用数据类型包括类、接口、数组、枚举和注解等...例如String就是Java中提供的一个类。

•  引用数据类型的值通常是按引用访问的，而不是按值访问，这意味着变量存储的是对象的地址，而不是对象本身的数据。

•  当修改引用数据类型的变量时，实际上是在修改它所引用的对象，而不是创建一个新的副本；此外，所有通过new关键字创建的对象都是引用数据类型。

2. 基本数据类型转换

✎. 基本数据类型转换（除boolean）分为两种：默认转换 和 强制转换

默认转换：小容量类型转为大容量类型.

（容量不是所占字节大小，如4个字节的float类型,容量大于8个字节的long类型）

byte/short/char ----> int ----> long ----> float ----> double      ( 容量由小到大 )

强制转换：大容量类型转为小容量类型 .

在使用强制转换时通常会出现两种问题： （1）溢出   （2）精度降低      使用时务必小心

📖 有多种类型的数据混合运算时，系统首先自动的将所有数据转换成容量最大的那一种数据类型，然后再进行计算。

int i = 'x';                  // 自动转换
char c = (char)60;            // 强制转换

3. 循环结构

（1）通常在不知道循环次数时用while循环

（2）若要求至少循环一次用do/while循环

（3）在知道循环次数时使用for循环

三. 数组

---

✎. 数组是一组相同类型数据的集合，本质是一个对象，数据存储在堆区，由引用指向数组首个元素的地址。

1. 创建数组

创建数组时，必须确定数组长度和类型；但如果储存的是基本类型，允许不赋初值（使用默认值）

int[] arr = new int[4];                    // 方法一
int[] arr = {1,2,3,4};                     // 方法二
int[] arr = new int[]{1,2,3,4};            // 方法三

2. 数组长度

在数组对象中，定义了 length 属性记录了数组长度。

int len = arr.length;                      // 返回数组长度  

---

📖Arrays类

✎. Java中为我们提供了Arrays类，是对数组进行操作的辅助类，实现了对数组的常用操作。

1. copyOf 方法

数组复制，将原数组内容复制到一个指定长度新数组中.

int[] arr1 = Arrays.copyOf(arr, 10);            // 复制数组：前 10 个单位
int[] arr2 = Arrays.copyOf(arr, 0, arr.length); // 复制数组：从 0 到 arr.length - 1

2. fill 方法

用指定的值 ，将指定数组中的值进行填充.

        int[]f = new int[5];
        Arrays.fill(f,6);
        System.out.println(Arrays.toString(f));//[6,6,6,6,6]
 

3. sort 方法

可以对数组排序，默认数组数值从小到大排列，用户可以自定义排列顺序.

Arrays.sort(arr);                           // 数组排序

4. binarySearch 方法

二分查找，查找前需要先排序.

        int[] b ={5,4,6,8,2,1,7};
        Arrays.sort(b);  //排序后 b={1,2,4,5,6,7,8}
        int index =Arrays.binarySearch(b,6); //需要找6
        System.out.println(index);  //输出索引,排序后6对应的索引为4

5. toString 方法

 将数组中的元素内容拼接成一个字符串输出.

        int[] a={1,2,3,4};
        System.out.println(a);  //输出数组首元素地址,不是数组的元素内容
        System.out.println(Arrays.toString(a));;//通过toString()输出元素内容

6. equals 方法

比较两个数组内容是否相等，返回值为boolean类型

        int[] a={1,2,3,4};
        int[] b={1,2,3,4};
        System.out.println(Arrays.equals(a,b));//true

7. asList 方法

将数组转化为列表（List 类）但数组数据必须是包装类型。

调用该方法将数组转换为列表后, 在内存中实际还是以数组形式存储, 这可能会导致以下两个问题：

• 调用 List 类的 add 方法向列表中插入数据，会导致异常；
• 对原数组进行更改，也会导致列表中的数据发生变化。

arr[] = new Integer[]{1, 2, 3, 4};                 // 数组必须是包装数据类型
List list = Arrays.asList(arr);                    // 将数组转换为集合（有问题）               
List list = new ArrayList<>(Arrays.asList(arr));   // 将数组转换为集合（推荐）  

四. 面向对象

---

什么是面向对象？

• 面向过程：根据解决问题的过程，直接设计系统。如 C 语言。

• 面向对象：将问题分解成多个对象，设计模块化、低耦合的系统。如 java 语言。

  • 特性：封装、继承、多态。

  • 优点：使系统更加灵活，易维护、易复用、易扩展。

1. 类(Class)

✎. 类具有相同特征（同一类）事物的抽象描述，如人类，车类，学生类等

类可以理解为对象的类型：定义对象含有的变量和方法。

public class Car {     
    // 变量
    String brand;
    String description = "this is a car";
    // static 变量 
    static int number_of_car;  
    // 构造方法
    public car(String brand){        
        this.brand = brand;
    } 
    // 方法  
    public void go(String loc){
        System.out.print("go to" + loc);
    }   
    // static 方法
    void static showNum(){            
        System.out.print(number_of_car);
    }
    // 初始化块
    {       
        number_of_car;                                      
    }
    // static 初始化块
    static{                                                              
        number_of_car = 0;
    }
    // 内部类
    public class Warranty{
        public void repair(){
            System.out.print("repair");
        }    
    }
}

• 变量

对象中存储的数据。

• 方法

调用时执行的代码。

• 初始化块

创建对象前自动执行的代码。

• 内部类

定义在类中的类。

• 构造方法

在创建对象时自动执行，不返回任何参数（先执行初始化块，再执行构造方法）。

未定义任何构造方法时，系统会自动添加无参构造方法。

---

终态声明

• final 常量： 只能赋值一次，不可更改。
• final 类： 不可被继承。
• final 方法：（弃用）不可被继承。现在所有的 private 方法都隐式地指定为 final。

对于 final 常量，如果编译时就可以确定值，编译器会在编译时直接把这个变量替换成它的值。

静态声明

• static 变量：该变量由该类的所有对象共享，不需要创建对象也可使用。
• static 方法：允许直接访问，不需要创建对象也可被调用。如 main 方法。
• static 初始化块：在创建类的第一个对象前自动执行（先执行静态初始化块，再执行初始化块）。
• static 内部类：外部类对象共享，只能访问外部类的静态成员。

权限声明

• public： 允许所有访问。
• protected： 只允许本类、同包和子类访问。
• [default]： 允许本类和同包访问。
• private： 只允许本类访问。

2. 对象(Object)

✎. 对象是类的实例，以类为模版，在内存中创建出一个实际存在的实例.

对象包含了状态和行为，用户通过调用对象的方法、改变对象的属性来实现 java 程序的功能。

Car myCar = new Car("BMW");               // 创建对象       
me.brand = "Benz";                        // 修改对象变量                   
me.go("London");                          // 调用对象方法

3. 特征—封装

✎. 将类中的某些信息,使用不同的访问权限修饰符隐藏起来,不让外界直接访问操作,而是通过类中向外提供的特定方法访问，方便加入控制语句，主动权在类手中。

将类中成员变量私有化

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

 此时在其他类中不能任意访问成员变量,只能通过类中提供的特殊的方法进行访问.

将类中的方法私有化

单例模式：让一个类在一个程序中只能创建一个对象,将类的构造方法私有化,外界不能随便用.

public class Window {
    //在类加载时，只创建了一个唯一对象
    static Window window = new Window();

    //将构造方法私有化，在外界不能随意调用
    private Window(){

    }
    //向外界提供可获得此对象的方法
    public  static  Window getWindow(){
        return window;
    }

    public static void main(String[] args) {
        System.out.println(Window.getWindow());
        System.out.println(Window.getWindow());
        System.out.println(Window.getWindow());
    }

}

可以看到，此例中创建的每个window的哈希值都相同于Window类中第一次创建的window

作用：可以有效的避免创建多个对象，达到在一个程序中只创建一个对象的作用。

---

4. 特征—继承

● 概念：将同一类事物中共性的属性和行为进行抽取，定义为一个类中（基类），其他类可以继承基类，就可以拥有基类中的功能，但不能使用基类中私有的内容。

● 作用：实现代码的复用性，以及可以在子类扩展自己特有的功能，而不影响其他类。

● 使用条件：只要符合is-a关系（什么是什么关系，比如苹果是水果），就可以使用继承，一个类只能直接继承一个类；而间接的可以继承多个类，称为继承的传递性，例如b继承a，然后c继承b，则c也继承了a.

● 继承的基本语法：

 在创建类的时候在类名后使用extends关键字 继承别的类，子类继承父类后，拥有了父类的成员变量和成员方法，但不能访问私有成员。

public class Cat extends Animal{
   //Cat继承Animal的成员变量和成员方法，但不能访问私有成员
}

● 注意：当一个类没有显示继承其他类的时候默认继承object类，Object类是java类体系中最大的类，Object类之上再也没有别的类。

---

5. 特征—多态

 前提：二者存在直接或间接的继承关系。

 概念：用父类的引用变量指向子类对象，多态也称向上转型，将子类类型转为父类类型。

 作用：用父类类型表示任意的子类类型对象，利于程序扩展。

Animal dog = new Dog();

两个时间段：

•  编译期 --- 类型是父类类型
•  运行期 --- 类型是具体的子类类型

 口诀：编译看左边，运行看右边 （ 若是静态方法则都看左边（父类））

 多态的存在意味着可以使用父类类型的引用来调用子类对象中重写的方法。

案例：

public class Animal {
    public void makeSound() {
        System.out.println("Animal is making a sound");
    }
}

public class Dog extends Animal{
    @Override//方法的重写
    public void makeSound() {
        System.out.println("Dog is barking");
    }

    public static void main(String[] args) {
        Animal dog = new Dog();//现在我们可以使用Animal类的引用来引用Dog对象

        dog.makeSound();  //输出Dog is barking
    }
}

○ 在上面的例子中，animal引用的是一个Dog对象，但是调用的是Dog类中重写makeSound()方法，这就是多态的效果！