JAVA基础学习路线

最新推荐文章于 2024-07-12 15:51:39 发布

ruanxiaoan

最新推荐文章于 2024-07-12 15:51:39 发布

阅读量119

点赞数 1

文章标签： java 学习 jvm

本文链接：https://blog.csdn.net/ruanxiaoan/article/details/130116162

版权

Java基础课程内容涉及：Java开发介绍、Java数组、Java面向对象、常用基础类、集合、IO流、多线程、异常、反射

数组的遍历访问（普通循环，增强for循环）

第一部分：Java开发介绍

DOS常用命令

cls 清屏
exit 退出DOS命令窗口
dir 列出当前目录下所有的子文件/子目录
cd 切换目录（使用方法：cd+目录的路径）路径有：绝对路径、相对路径。
cd.. 回到上级目录
cd\ 回到根目录
怎么切换盘符： c: 回车 d: 回车 e: 回车

JVM、JRE、JDK之间的关系

JDK（Java Development Kit）简单理解就是Java开发工具包，是java的核心所在；JRE(Java Runtime Enviroment)是Java的运行环境，JVM( java virtual machine)也就是常常听到Java虚拟机。JDK是面向开发者的，JRE是面向使用JAVA程序的用户，JVM是java实现跨平台和系统的媒介所在。

JDK包含JRE，而JRE包含JVM；JDK是用于java程序的开发,而JRE则是只能运行class而没有编译的功能，所编译的class文件都必须通过JVM去执行字节码文件。java的特点之一是跨平台，它不是JAVA跨平台，而是JVM跨平台，在不同的操作系统上有不同的jvm虚拟机，因jvm，java有着“一处执行，处处执行”的特点。

Java基本数据类型

整数类型：byte，1字节，8位，最大存储数据量是255，存放的数据范围是-128~127之间。

整数类型：short，2字节，16位，最大数据存储量是65536，数据范围是-32768~32767之间。

整数类型：int，4字节，32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

整数类型：long，8字节，64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。

浮点类型：float，4字节，32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。

浮点类型：double，8字节，64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

字符型：char，2字节，16位，存储Unicode码，用单引号赋值。

布尔型：boolean，只有true和false两个取值

变量和常量的定义及初始化

变量的定义：

变量是内存中的一个存储区域，该区域有自己的名称（变量名）和类型（数据类型），Java中每个变量必须先声明，后使用，该区域的数据可以在同一类型范围内不断变化。

变量的分类：

按数据类型 :

          对于不同的数据类型，在内存中分配了不同大小的内存空间
          数据类型分为基本数据类型和引用数据类型，引用数据类型有类（class）、接口（interface）、数组，基本数据类型有布尔型（boolean）、字符型（char）、数值性【整数类型（byte、short、int、long）、浮点类型（float、double）】

按声明的位置:

  在方法体外，类体内声明的变量称为成员变量；在方法体内部声明的变量称为局部变量

声明格式：

定义变量的格式：数据类型变量名 = 初始化值

常量：

常量是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变，一般用大写字符

语法：final 常量名 = 值;

如：final String LOVE = ‘java‘;

注意：必须要在常量声明的时候就对其进行初始化，否则会出现编译错误。常量一旦初始化后就无法再改动

字符型常量的三种表现形式：

字符常量是用单引号(‘ ’)括起来的单个字符，涵盖世界上所有书面语的字符。例如：char c1 = ‘a‘; char c2 = ‘中‘; char c3 = ‘9‘;
Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘\n’; // ‘\n‘表示换行符
直接使用 Unicode 值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。如：\u000a 表示 \n

第二部分：Java数组

Java 数组的定义

数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。
其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们。

Java 数组的声明

首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法:

dataType[ ] arrayRefVar; //首选的方法或 dataType arrayRefVar[ ]; //效果相同，但不是首选方法

Java语言使用new操作符来创建数组，语法如下:

dataType[ ] arrayRefVar = new dataType[ arraySize];

数组的元素是通过索引访问的，数组索引从О开始。
获取数组长度:

arrays.length

数组的优势与局限

优点：

随机访问的效率很高。根据下标访问元素效率高（元素连续分配空间）
数组可以保存若干个数据

缺点：

数组长度是固定的不能变的，不能自动扩容
数组进行元素的删除和插入操作的时候，效率比较低。需要移动大量的元素
数组元素的类型只能是一种
数组通过内容查找元素的效率是比较低的，需要逐个比较
数组的元素是连续分配的，所以在 heap 内存中必须找到连续的内存空间才能容纳数组的所有数据。对内存要求高一些
数组没有提供任何的封装，所有对元素的操作，都是通过自定义的方法实现的，对数组元素的操作比较麻烦

数组较容器，最大的优点就是效率。

数组的优点是效率高，但为此，所付出的代价就是数组对象的大小被固定。这也使得在工作中，数组并不实用。所以我们应该优选容器，而不是数组。只有在已证明性能成为问题的时候，并且确定切换到数组对性能提高有帮助时，才应该将项目重构为使用数组。

数组的遍历访问（普通循环，增强for循环）

普通循环

首先我们要知道数组元素下标的合法区间：[0, length-1]（即从0开始到数组长度减一）。我们可以通过下标来遍历数组中的元素，遍历时可以读取或修改元素的值。

代码：

public class Test {

  public static void main(String[] args) {
    int[] a = new int[4];
    // 初始化数组元素的值
    for (int i = 0; i < a.length; i++) {
      a[i] = 100 * i;`
    }

    // 读取元素的值
    for (int i = 0; i < a.length; i++) {
      System.out.println(a[i]);
    }

  }

}

增强 for 循环

增强for循环（foreach）是 JDK1.5 新增加的功能，专门用于读取数组或集合中所有的元素，即对数组进行遍历。

代码：

public class Test {

  public static void main(String[] args) {
    String[] strings = {"aaa", "bbb", "ccc", "ddd"};
    for (String str : strings) {
      System.out.println(str);
    }
  }

}

注：仅适合于遍历，不可修改元素的值，不涉及有关索引（下标）的操作。

增强 for 循环使用起来比较方便，代码也比较简单，如果只是操作数组或集合中的元素而不使用索引的话，建议使用增强 for 循环；如果需要使用索引进行其它操作的话，建议使用普通循环。

普通循环和增强 for 循环的区别

增强 for 循环必须有被遍历的目标（如数组或集合）。
普通 for 循环遍历数组的时候需要索引。
增强 for 循环不能获取下标，所以遍历数组时最好使用普通for循环。

数组元素的冒泡法排序

数组的冒泡排序就是将数组元素两两比较，较大的元素后移，例如有一数组array，array[1] > array[2]，那么将array[1]后移，即将array[1]与array[2]中的元素互换，互换之后继续开始比较array[2]与array[3]… 当数组中最后两个元素比完之后，能选出该数组中最大的元素。接着开始第二轮比较，由于已经将最大的数确定在了最后一位，所以这一轮比到到数组倒数第二个元素就结束了,接着以此类推，直到将数组元素按升序排列完成为止。降序也可以这样操作。

代码：

public class ArraySorting{
    public static void main(String[] args){
        int[] array = {63,32,12,80,77};
        for(int j = 0; j < array.length; j++){
            for(int i = 0; i < array.length-1-j; i++){
                if(array[i] > array[i+1]){
                    int temp = array[i+1];                
                    array[i+1] = array[i];
                    array[i] = temp;
                }
            }    
        }
       	for(int i = 0; i < array.length; i++){
            System.out.print(array[i] + " ");
        }
    }
}

Arrays工具类的使用

JDK提供的java.util.Arrays类，包含了常用的数组操作，方便日常开发。Arrays类包含了：排序（Arrays.sort）、查找(Arrays.binarySearch)、打印(Arrays.toString)内容等常见操作。

代码：

import java.util.Arrays;

/**
 *测试java.util.Arrays工具类的使用
 */
public class TestArrays {
	public static void main(String[] args) {
		int[] a={3,1,2,74,4,50};
		System.out.println(a);//打印数组引用的值
		System.out.println(Arrays.toString(a));//打印数组元素的值
		Arrays.sort(a);//排序
		System.out.println(Arrays.toString(a));
		System.out.println(Arrays.binarySearch(a, 50));
	}
}

二维数组

二维数组的定义：类型数组名 [行号] [列号]

eg：int arr[3] [4]

第三部分：Java面向对象

面向对象设计思想

面向过程(POP)

分析出解决问题所需要的的步骤，然后把步骤一步一步实现。

面向过程直接关注流程。

面向对象（OOP）

以分类的方式进行思考和解决问题

面向对象先对整体关系作出分类，然后根绝不同的类深入细节的处理。

面向对象与面向过程之间的关系

面向过程与面向对象

面向对象无法取代面向过程，他们是相辅相成的。面向对象关注于从宏观上把握事物之间的关系，在具体到如何实现某个细节时，仍然采用面向过程的思维方式。面向对象如果离开了面向过程，就无法实现真正的落地，成为无源之水。

面向对象的分析与设计

Java与面向对象

面向对象就是把构成问题的事物分解成一个个对象，建立对象不是为了实现一个步骤，而是为了描述某个事物在解决问题中的行为。

类是面向对象中的一个很重要的概念，因为类是很多个具有相同属性和行为特征的对象所抽象出来的，对象是类的一个实例

类具有三个特性：封装、继承和多态。

封装：核心思想就是“隐藏细节”、“数据安全”，将对象不需要让外界访问的成员变量和方法私有化，只提供符合开发者意愿的公有方法来访问这些数据和逻辑，保证了数据的安全和程序的稳定。
继承：子类可以继承父类的属性和方法，并对其进行拓展。
多态：同一种类型的对象执行同一个方法时可以表现出不同的行为特征。通过继承的上下转型、接口的回调以及方法的重写和重载可以实现多态。

类中成员变量的定义与意义

变量定义

成员变量：是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。（成员变量亦称实例变量）

类变量：类变量也声明在类中，方法体之外，但必须声明为statich类型。（类变量亦称静态变量）

成员变量和静态变量的区别：

成员变量所属于对象。所以也称为实例变量。静态变量所属于类。所以也称为类变量。
成员变量存在于堆内存中。静态变量存在于方法区中。
成员变量随着对象创建而存在。随着对象被回收而消失。静态变量随着类的加载而存在。随着类的消失而消失。
成员变量只能被对象所调用。
静态变量可以被对象调用，也可以被类名调用，所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

static 关键字 static 关键字，是一个修饰符，用于修饰成员(成员变量和成员函数)。

特点：

想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。
被静态修饰的成员，可以直接被类名所调用。也就是说，静态的成员多了一种调用方式。类名.静态方式。
静态随着类的加载而加载。而且优先于对象存在。

弊端：

有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。
静态方法只能访问静态成员，不可以访问非静态成员。因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。
静态方法中不能使用this，super关键字。因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

静态属性、静态方法、静态代码块

什么是静态属性、静态方法：

用static修饰符修饰的属性和方法叫作静态属性和静态方法

静态属性和非静态属性的区别：

在内存中存放的位置不同：所有static修饰的属性和方法都存放在内存的方法区里，而非静态的都存在堆内存中
出现的时机不同：静态属性和方法在没创建对象之前就存在，而非静态的需要在创建对象才存在
静态属性是整个类都公用的
生命周期不一样，静态在类消失后被销毁，非静态在对象销毁后销毁
用法：静态的可以直接通过类名访问，非静态只能通过对象进行访问

使用static的注意事项：

带静态修饰符的方法只能访问静态属性
非静态方法既能访问静态属性也能访问非静态属性
非静态方法不能定义静态变量
静态方法不能使用this关键字
静态方法不能调用非静态方法，反之可以

静态代码块

静态代码块只能写在类中方法外，不能写在方法中，它会随着类的加载而优先于各种代码块和构造方法的加载，并且只会

加载一次，如果出现多个静态代码块，会按照书写顺序加

静态代码块的作用： 一般情况下，有些代码需要在项目启动的时候就执行，这时候就需要静态代码块，比如一个项目启动需要加载配置文件，或初始化内容等。

静态代码块不能出现在任何方法体内 对于普通方法：普通方法是需要加载类new出一个实例化对象，通过运行这个对象才能运行代码块，而静态方法随着类加载就运行了。对于静态方法：在类加载时静态方法也加载了，但是必须需要类名或者对象名才可以访问，相比于静态代码块，静态方法是被动运行，而静态代码块是主动运行

静态代码块不能访问普通变量 普通变量只能通过对象调用的，所以普通变量不能放在静态代码块中。

执行顺序：

静态代码块>构造代码块>构造函数>普通代码块

接口

接口就是多个类的公共规范接口中最重要的就是抽象方法

接口可以包括：

常量、抽象方法(Java7)
默认方法、静态方法(Java8)
私有方法(Java9)

接口的抽象方法

接口不能直接使用，必须有一个"实现类"来"实现"该接口
接口的实现类必须覆盖重写(实现)接口中所有的抽象方法

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

public class My_interface_abstract_Impl implements My_interface_abstract {
  
  @Override
    public void method() {
        System.out.println("特朗普");
    }
}

public class test {
    public static void main(String[] args) {
        var impl = new My_interface_abstract_Impl();
        impl.method();
    }
}
//输出结果 特朗普