JAVA学习笔记

Java简介

Java是一门面向对象编程语言，功能强大且简单易用。

Java经常需要new个对象，而面向对象就是面向对象的编程，由Object Oriented Programming翻译而来，简称OOP。

最初编程是面向过程的，通过算法来解决问题。但是随着时代的进步，使用算法来解决问题太过困难，因为问题越来越复杂，因此就有了对象这个概念。我们将现实的事物抽象出来，把现实生活的事物以及关系，抽象成类，通过继承，实现，组合的方式进行编程。

面向过程是具体化的，流程化的，解决一个问题，你需要一步一步的分析，一步一步的实现。

面向对象是模型化的，我们只需抽象出一个类，类相当于一个盒子，在这里你拥有数据也拥有解决问题的方法。需要什么功能直接使用就可以了，不必去一步一步的实现。

抽象来说，面向过程相当于自己炒菜，面向对象相当于去菜馆点菜。

因此Java作为面向对象的编程语言，功能强大且简单易用。

版本

Java SE（标准版）

Java SE 以前称为 J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为Java EE和Java ME提供基础。

Java EE（企业版）

Java EE 以前称为 J2EE。企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端Java 应用程序。Java EE 是在 Java SE 的基础上构建的，它提供 Web 服务、组件模型、管理和通信 API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和 Web2.0应用程序。

Java ME（微型版）

Java ME 以前称为 J2ME。Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。Java ME 包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于 Java ME 规范的应用程序只需编写一次，就可以用于许多设备，而且可以利用每个设备的本机功能。

名词解释

JVM

Java Virtual Machine的缩写，Java虚拟机的意思；用于加载.class字节码文件并运行.class字节码文件。

JRE

Java Runtime Environment的缩写，JRE包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包：包含了运行Java程序必不可少的系统类，如基本数据类型、基本数学函数、字符串处理、线程、异常处理类等，系统缺省加载这个包。

如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

JDK

Java Development Kit是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。所以安装了JDK，就无需再单独安装JRE了。

其中的开发工具：编译工具(javac.exe)，打包工具(jar.exe)等。

关系图

Java标识符

标识符定义

凡是可以由自己命名的地方都称为标识符。

例如，对于常量、变量、函数、语句块、类、项目等都需要一个名字，这些我们都统统称为标识符。

标识符命名规范

• 类名和接口名：每个单词的首字母，其余为小写。（大驼峰）

  举例：Student,Car,HelloWorld

• 方法名：第二个单词起的首字母为大写，其余全为小写。（小驼峰）

  举例：age,maxAge,show(),getAge()

• 常量名：基本数据类型的常量名使用全部大写字母，字与字之间用下划线分隔。

  举例：DATE,MAX_AGE

• 项目名：全部用小写字母，多个单词之间用横杆-分割。

  举例：demo，spring-boot

• 包名：全部小写，多级包用.隔开。

  举例：com.jourwon

注意

1.标识符有字母、数字、_(下划线)、$所组成，其中不能以数字开头，不能用Java中的保留字（关键字）

2.标识符采用有意义的简单命名

3." " 不要在代码中出现。（在后面内部类中，编译后会出现 "不要在代码中出现。（在后面内部类中，编译后会出现 "不要在代码中出现。（在后面内部类中，编译后会出现符号）

Java关键字

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循[IEEE 754](https://baike.baidu.com/item/IEEE 754)算术规范 [1]
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

Java流程控制语句

顺序结构

/*
 * 顺序结构：从上往下，依次执行
 */
public class OrderDemo {
	public static void main(String[] args) {
		System.out.println("A");
		System.out.println("B");
		System.out.println("C");
	}
}

分支结构

分支结构是一种编程结构，用于根据条件的不同选择不同的执行路径。在分支结构中，程序会根据某个条件的真假来决定执行哪个代码块。常见的分支结构有 if-else、switch等。

if-else语句是最常见的分支结构之一，它根据条件的真假执行不同的代码块。if语句会先判断条件是否为真，如果为真，则执行if代码块中的语句；如果条件为假，则执行else代码块中的语句。

if-else结构:

public class BranchExample {
    public static void main(String[] args) {
        int num = 10;
        if (num > 0) {
            System.out.println("num是正数");
        } else {
            System.out.println("num是负数或零");
        }
    }
}

switch结构：

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        String dayName;

        switch (day) {
            case 1:
                dayName = "星期一";
                break;
            case 2:
                dayName = "星期二";
                break;
            case 3:
                dayName = "星期三";
                break;
            case 4:
                dayName = "星期四";
                break;
            case 5:
                dayName = "星期五";
                break;
            case 6:
                dayName = "星期六";
                break;
            case 7:
                dayName = "星期日";
                break;
            default:
                dayName = "无效的输入";
        }

        System.out.println("今天是" + dayName);
    }
}

循环结构

Java提供了三种主要的循环结构：for循环、while循环和do-while循环。

for循环：

for循环是一种在已知循环次数的情况下使用的循环结构。它由三个部分组成：初始化表达式、循环条件和循环迭代。

for (初始化表达式; 循环条件; 循环迭代) {
    // 循环体代码
}

初始化表达式在循环开始前执行一次，循环条件在每次循环开始前进行检查，如果条件为真，则执行循环体代码，然后执行循环迭代，再次检查循环条件。这个过程会一直重复，直到循环条件为假时跳出循环。

while循环：

while循环用于在循环开始之前不知道循环次数的情况下执行循环。它只包含一个循环条件，当循环条件为真时执行循环体代码。

while (循环条件) {
    // 循环体代码
}

在每次循环开始前，会先检查循环条件是否为真，如果是，则执行循环体代码，然后再次检查循环条件。这个过程会一直重复，直到循环条件为假时跳出循环。

do-while循环：

do-while循环与while循环非常相似，但不同的是，在执行循环体代码之前，先判断循环条件。这意味着无论循环条件的结果如何，循环体代码至少会执行一次。

do {
    // 循环体代码
} while (循环条件);

首先执行循环体代码，然后检查循环条件。如果循环条件为真，则继续执行循环体代码，然后再次检查循环条件。这个过程会一直重复，直到循环条件为假时跳出循环。

这些循环结构可以嵌套使用，可以根据具体的需求选择最合适的循环结构来解决问题。同时，需要注意在循环体内部使用控制语句如break和continue来控制循环的执行流程。

Java变量

变量

变量是存储数据值的容器。

在 Java 中，有不同类型的变量，例如：

String- 存储文本，例如"hello"。字符串值用双引号括起来

int - 存储整数（整数），不带小数，例如 123 或 -123

float - 存储带小数的浮点数，例如 19.99 或 -19.99

char- 存储单个字符，例如 'a' 或 'B'。char 值用单引号括起来

boolean - 存储具有两种状态的值：真或假

最终变量

如果不希望变量现有值被覆盖，则可以添加关键字（这会将变量声明为"final"或"constant"，这意味着不可更改和只读）。

package test;

public class t {
	public static void main(String[] args) {
	final int myNum = 5;
    myNum = 20; // 报错
    System.out.println(myNum);
	}
}

显示变量

println()方法通常用于显示变量。要组合文本和变量，可以使用文本+字符。

例如：

package test;

public class t {

	public static void main(String[] args) {
		String name = "啊啊";
		System.out.println("你好 " + name);
	}

}

还可以使用该+字符将一个变量添加到另一个变量中

package test;

public class t {

	public static void main(String[] args) {
		String firstName = "啊啊";
		String lastName = "你好";
		String fullName = firstName + lastName;
		System.out.println(fullName);
	}

}

Java常量

常量定义：在程序执行的过程中，其值不可以发生改变的量。

例：Java 语言使用 final 关键字来定义一个常量
final int COUNT=10;
final float HEIGHT=10.2F;

在Java中，后缀"F"用于表示浮点数字面值是单精度浮点数（float）而不是双精度浮点数（double）。当字面值带有小数点时，默认情况下会被认为是双精度浮点数。为了显式指定一个值为单精度浮点数，可以在数字后面添加"F"或"f"后缀。

在上述示例中，10.2F表示一个单精度浮点数。如果不添加"F"后缀，编译器会将该数字默认为双精度浮点数，并产生一个编译错误，因为你在声明变量时使用的是float，而不是double类型。

注意事项

• 在定义常量时就需要对该常量进行初始化。
• final 关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。
• 为了与变量区别，常量取名一般都用大写字符。

数组

数组(array)是一种用于存储多个相同类型数据的存储模型。

数组定义格式：

1、数据类型[] + 数组名

int[] arr;        
double[] arr;      
char[] arr;

2、数据类型 + 数组名[] (不推荐)

int arr[];
double arr[];
char arr[];

数组动态初始化：

//格式
//数据类型[] 数组名 = new 数据类型[数组长度];

int[] arr = new int[3];

方法概述

概念

方法（method）是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

• 注意：
  • 方法必须先创建才可以使用，该过程成为方法定义
  • 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用

无参数方法的定义和调用

介绍

定义：

//格式
public static void 方法名 (   ) {
	// 方法体;
}

//范例
public static void method (    ) {
	// 方法体;
}

调用：

//格式
方法名();

//范例
method();

• 注意：

  方法必须先定义，后调用，否则程序将报错

练习

• 需求：设计一个方法用于打印两个数中的较大数
• 思路：
  • ①定义一个方法，用于打印两个数字中的较大数，例如getMax()
  • ②方法中定义两个变量，用于保存两个数字
  • ③使用分支语句分两种情况对两个数字的大小关系进行处理
  • ④在main()方法中调用定义好的方法
• 代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法
        getMax();
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    public static void getMax() {
        //方法中定义两个变量，用于保存两个数字
        int a = 10;
        int b = 20;

        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

带参数方法的定义和调用

介绍

定义：

//格式
public static void 方法名 (参数1) {
	方法体;
}

public static void 方法名 (参数1, 参数2, 参数3...) {
	方法体;
}

//范例
public static void isEvenNumber(int number){
    ...
}
public static void getMax(int num1, int num2){
    ...
}

调用：

//格式
方法名(参数)；

方法名(参数1,参数2);

//范例
isEvenNumber(10);

getMax(10,20);

练习

• 需求：设计一个方法用于打印两个数中的较大数，数据来自于方法参数

• 思路：

  • ①定义一个方法，用于打印两个数字中的较大数，例如getMax()
  • ②为方法定义两个参数，用于接收两个数字
  • ③使用分支语句分两种情况对两个数字的大小关系进行处理
  • ④在main()方法中调用定义好的方法（使用常量）
  • ⑤在main()方法中调用定义好的方法（使用变量）

• 代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法（使用常量）
        getMax(10,20);
        //调用方法的时候，人家要几个，你就给几个，人家要什么类型的，你就给什么类型的
        //getMax(30);
        //getMax(10.0,20.0);

        //在main()方法中调用定义好的方法（使用变量）
        int a = 10;
        int b = 20;
        getMax(a, b);
    }

    //定义一个方法，用于打印两个数字中的较大数，例如getMax()
    //为方法定义两个参数，用于接收两个数字
    public static void getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        if(a > b) {
            System.out.println(a);
        } else {
            System.out.println(b);
        }
    }
}

带参数方法的定义和调用

介绍

定义：

//格式
public static 数据类型 方法名 ( 参数 ) { 
	return 数据 ;
}

//范例
public static boolean isEvenNumber( int number ) {           
	return true ;
}
public static int getMax( int a, int b ) {
	return  100 ;
}

调用：

//格式
方法名 ( 参数 ) ;
数据类型 变量名 = 方法名 ( 参数 ) ;

//范例
isEvenNumber ( 5 ) ;
boolean  flag =  isEvenNumber ( 5 ); 

• 注意：
  • 方法的返回值通常会使用变量接收，否则该返回值将无意义

练习

• 需求：设计一个方法可以获取两个数的较大值，数据来自于参数
• 思路：
  • ①定义一个方法，用于获取两个数字中的较大数
  • ②使用分支语句分两种情况对两个数字的大小关系进行处理
  • ③根据题设分别设置两种情况下对应的返回结果
  • ④在main()方法中调用定义好的方法并使用变量保存
  • ⑤在main()方法中调用定义好的方法并直接打印结果
• 代码：

public class MethodTest {
    public static void main(String[] args) {
        //在main()方法中调用定义好的方法并使用变量保存
        int result = getMax(10,20);
        System.out.println(result);

        //在main()方法中调用定义好的方法并直接打印结果
        System.out.println(getMax(10,20));
    }

    //定义一个方法，用于获取两个数字中的较大数
    public static int getMax(int a, int b) {
        //使用分支语句分两种情况对两个数字的大小关系进行处理
        //根据题设分别设置两种情况下对应的返回结果
        if(a > b) {
            return a;
        } else {
            return b;
        }
    }
}

方法的注意事项：方法不能嵌套定义