1. 知道java的main办法

Java基础语法（一）

  1. 一个java文件傍边只能有一个public的类。
  2. 且 类名 需求和 文件名 是相同的。

比方，文件名为HelloWorld.java，所以此处的类名为HelloWorld

  1. 编程标准主张：左括号 是紧跟着当时行的。
  2. 类名 一定要选用大驼峰的形式（单词紧跟着，每个单词的首字母大写）
  3. 留意：字节码文件 .class文件，一个类对应一个字节码文件

如，一个.java文件里边有两个类，则有两个字节码文件。

Java基础语法（一）
Java基础语法（一）
那为什么要这样设置呢？ 为了方便运用，Java傍边，用到哪个类就加载哪个类。

Java基础语法（一）

运转时指令行参数

public static void main (String[] args) {
	}

上述main函数的形参String[] args是运转时指令行参数。咱们下面做个测试：

public static void main (String[] args) {
    int i = 0;
    for (i = 0; i < args.length; ++i)
    {
        System.out.println(args[i]);
    }
    System.out.println("kaixin");
}

能够看到只输出了“kaixn”，没有输出for循环里边的值。

Java基础语法（一）

当咱们在java 文件名后输入一些字符串，字符串就被存储到args里边了，就能够打印出for循环里边的内容了。
Java基础语法（一）

2. 怎么运转一个java程序

Java基础语法（一）

  1. 首要，比方文件HelloWorld.java是寄存在磁盘上的。
  2. 编译该文件，运用javac 文件名.java，构成 .class文件。

留意：

  1. 在cmd上编译文件，需求将当时目录改为文件地点目录，运用指令cd /d 文件途径

Java基础语法（一）

2. 在记事本上写代码，需求先保存，再编译。

Java基础语法（一）

编译完后，可在当时目录中看到 .class文件
Java基础语法（一）

  1. 运用java 文件名来运转文件（在JVM（java虚拟机）里运转）

Java基础语法（一）

留意：java 和 javac 都属于JDK指令。

Java基础语法（一）

3. Java傍边的注释

  • 块注释（快捷键，选中要注释的内容，ctrl+shift+/）
/*这是块注释*/
  • 文档注释
/**
 * 文档注释：
 * 作者：
 * 日期：
 * 描绘：
*/
  • 行注释（快捷键：ctrl+/）
// 这是行注释

可是假如程序里边有注释，编译的时分会呈现过错，如下图：

Java基础语法（一）

Java基础语法（一）

原因是，代码里边有中文，可是javac编译默许运用GBK来编码的，这便是“字节码格局不匹配导致”的。
这时分咱们只需求在后面加-encoding utf-8编译即可：
Java基础语法（一）

这就告知编译器，通通以utf-8来编码。

4. 打印数据

有三种办法打印：

Java基础语法（一）

成果如下：
Java基础语法（一）

5. 数据类型

5.1 根本数据类型

  • 长整型（long）
public static void main1 (String[] args) {
    long a = 10L;
    System.out.println(a);
    System.out.println("最大值：" + Long.MAX_VALUE); // + 为拼接
    System.out.println("最小值：" + Long.MIN_VALUE);
    int b = 10;
    int c = 20;
    System.out.println(b + c);
    //留意：任何类型的数据 和 字符串进行拼接，成果都是字符串
    System.out.println("hhh" + b + c);
}
  • 双精度浮点型（double）
/**
	 *	双精度 浮点型
	 * @param args [description] 
	 */
public static void main3 (String[] args) {
    double d = 12.5;
    System.out.println(d);
    System.out.println(Double.MAX_VALUE);
    System.out.println(Double.MIN_VALUE);
}
  • 单精度浮点型（float）：界说变量数值的时分，需求加上f或F 
/**
	 * 单精度 float
	 * 1.  double  8个字节
	 * 2.  float   4个字节
	 */
public static void main4 (String[] args) {
    // float f = 12.3; 会呈现过错，不允许从double类型转到float类型
    float f = 12.3f;
    System.out.println(f);
    System.out.println(Float.MAX_VALUE);
    System.out.println(Float.MIN_VALUE);
}
  • 字符型（char）
/**
	 *	字符数据类型：
	 * 		char 	2个字节  0 ~ 65535
	 * Unicode --> 包括许多字符集，如中文，拉丁文等等
	 */
public static void main5 (String[] args) {
    char ch = 'a';
    System.out.println(ch);
    char ch2 = '高';
    System.out.println(ch2);
    char ch3 = 97;
    System.out.println(ch3); 
}
  • 字节型（byte）
// 字节：byte 1个字节 数值：-128 ~ 127
// 每一种数据类型，在给其赋值的时分，一定不能超过它的规模
public static void main6 (String[] args) {
    byte b = 12;
    byte c = 21;
    System.out.println(b + " " + c);
    // byte d = Byte.MAX_VALUE + 1;此处会进行整型提升,从int->byte会编译过错
    System.out.println(Byte.MAX_VALUE + 1); //默许输出整型，整型是能够保存数值128的
    System.out.println(Integer.MAX_VALUE);
    //int i1 = 2147483648; //报错，超出数据类型的规模(Java只会检查 直接赋值的字面值常量是否超出)
    //下面的均不会编译报错
    int i2 = 2147483647 + 1;
    System.out.println(i2);
    int i3 = Integer.MAX_VALUE + 1;
    System.out.println(i3);
    System.out.println(Integer.MAX_VALUE + 1);
}
  • 短整型（short）
//短整型：short  2个字节 数值：-32768 ~ 32767
public static void main7 (String[] args) {
    short sh = 12;
    System.out.println(Short.MAX_VALUE);
    System.out.println(Short.MIN_VALUE);
}
  • 布尔型（boolean）
/**
	 * 布尔类型：
	 * 1.在JAVA中，布尔类型 没有清晰的大小
	 * 2.在JAVA中，布尔类型 只有两个取值 true 和 false
	 * 3.在JAVA中，没有 所谓的 0是假 非0是真
	 */
public static void main7 (String[] args) {
    boolean flg = true;
    System.out.println(flg);
    //报错，只能为布尔值
    /*if (1) {
		}*/
}

Java基础语法（一）

5.2 引证数据类型

String

语法格局：String 变量名 = "初始值";

  • 能够运用转义字符
String name = "My name is \"张三\"";
  • 字符串的+操作，表明字符串拼接：
String a = "hello";
String b = "world";
String c = a + b;
//输出 helloworld
System.out.println(c);
  • 还能够用字符串和整数进行拼接：
String str = "result = ";
int a = 10;
int b = 20;
String result = str + a + b;
//输出为result = 1020
System.out.println(result);

数组（Arrays：操作数组的工具类）

数组的创立

T[] 数组名 = new T[N];
T：表明数组中寄存元素的类型。

T[]：表明数组的类型。

N：代表数组的长度。

int[] arr1 = new int[10];	//创立一个能够包容10个int类型元素的数组
double[] arr1 = new double[5];	//创立一个能够包容5个double类型元素的数组

跟C言语不同，Java数组是创立在堆上的，不像C言语创立在栈上的。

数组的初始化

分为两种：动态初始化，静态初始化。

  1. 动态初始化：在创立数组时，直接指定数组中元素的个数。
int[] array = new int[10]; //里边寄存了10个0
  1. 静态初始化：在创立数组时不直接指定数据元素个数，而直接将详细的数据内容进行指定。

语法格局：T[] 数组称号 = {data1,data2,.....,datan};

int[] array = new int[]{1,2,3,4};

array是拓荒在栈上，存储的是数组的首地址，数组是拓荒在堆上的。也便是说，array是指向{1,2,3,4}这个目标的。

这个时分就有个问题：咱们能拿到栈上的地址吗？（比方 int a = 10; 能拿到a 的地址吗？）
答案是：不能，Java很安全，不会让你拿到栈上的地址的。

Java基础语法（一）

【留意事项】：

  1. 静态初始化尽管没有指定数组的长度，编译器在编译时会依据 {} 中元素个数来确认数组的长度。
  2. 静态初始化时，{} 中数据类型有必要与[]前数据类型共同。
  3. 静态初始化能够简写，省去后面的 new T[]。
  4. 假如不确认数组傍边内容时，运用动态初始化，不然主张运用静态初始化。
  5. 静态和动态初始化可分为两步，可是省掉格局不能够：
int[] array1;
array1 = new int[10];
int[] array2;
array2 = new int[]{10, 20, 30};
//留意省掉格局不能够拆分，不然编译失败
// int[] array3;
// array3 = {1, 2, 3};
  1. 假如没有对数组进行初始化，数组中元素有其默许值：
    • 若数组中存储元素类型为基类类型，默许值为基类类型对应的默许值，如：

Java基础语法（一）

  • 假如数组中存储元素类型为引证类型，默许值为null。

#### 数组的运用
数组中元素的拜访

数组在内存中是一段接连的空间，空间的编号都是从0开始的，顺次递加，该编号称为数组的下标，可通过下标拜访数组任意方位的元素。
可是，假如下标越界则会报出下标越界反常。

int[] arr = {1,2,3};
System.out.println(arr[3]); //会抛出越界反常

上面代码的反常为java.lang.ArrayIndexOutOfBoundsException。

遍历数组

有三种遍历办法：

  1. for 循环遍历
int[] arr = new int[]{1,2,3,4,5,6,7};
for(int i = 0; i < arr.length;++i) {
    System.out.print(arr[i] + " ");
}

在数组中能够通过 数组目标 .length 来获取数组的长度。

  1. for-each遍历
int[] arr = new int[]{1,2,3,4,5,6,7};
for (int e : arr) {
    System.out.print(e + " ");
}
  1. 运用类Arrays的办法toString，将数组以字符串的形式输出 
import java.util.Arrays; // 需包括该类
int[] arr = new int[]{1,2,3,4,5,6,7};
System.out.println(Arrays.toString(arr));
//输出
//[1,2,3,4,5,6,7]

初始JVM的内存散布

内存是一段接连的存储空间，主要用来存储程序运转时的数据。如：

  1. 程序运转时代码需求加载到内存。
  2. 程序运转发生的中心数据要寄存在内存。
  3. 程序中常量也要保存。
  4. 有些数据可能需求长时间存储，而有些数据当办法运转结束后就要被毁掉。

假如对内存中存储的数据不加区分的随意存储，那对内存管理起来将会非常麻烦。
因而 JVM 也对所运用的内存按照功能的不同进行了划分：

Java基础语法（一）

  • **程序计数器（PC Register）：**只是一个很小的空间，保存下一条指令的地址。

> – **虚拟机栈（JVM Stack）：**与办法调用相关的一些信息，**每个办法在执行时，都会先创立一个栈帧，**栈帧包括**局部变量表、操作数栈、动态链接、回来地址**以及其他的一些信息，保存的都是与办法执行时相关的一些信息。比方：局部变量。**当办法运转结束后，栈帧就被毁掉，即栈帧中保存的数据也被毁掉了。** >
> – **本地办法栈（Native Method Stack）：**本地办法栈和虚拟机栈的效果类似，只不过**保存的内容是Native办法的局部变量。（Native办法：底层是用C/C++写的，运转速度快）。** >
> – **堆（Heap）：**JVM所管理的最大内存区域。运用**new 创立的目标都是在堆上保存**（例如前面的`new int[]{1,2,3}`)，**堆是跟着程序开始运转时而创立，跟着程序的退出而毁掉，堆中的数据只需还有在运用，就不会被毁掉。** >
> – **办法区（Method Area）：**用于**存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。**办法编译出的字节码便是保存在这个区域。

根本类型变量与引证类型变量的差异

根本数据类型创立的变量，称为根本变量，该变量空间中直接寄存的是其所对应的值。
引证数据类型创立的变量，一般称为目标的引证，其空间中存储的是目标地点空间的地址。

public static void func(){
    int a = 10;
    int b = 20;
    int[] arr = new int[]{1,2,3};
}

下面是寄存示意图：

Java基础语法（一）

知道null

null 在Java中表明“空引证”，也便是一个不指向目标的引证。

Java基础语法（一）

Java基础语法（一）

null 的效果类似于C言语中的NULL（空指针），都是表明一个无效的内存方位。因而不能对这个内存进行任何读写操作，一旦测验读写，就会抛出 NullPointerException。

留意：java中并没有约定 null 和 0 号地址的内存有任何相关。


#### 数组作为函数的参数 “`java public class Demo_arr2 { public static void main(String[] args) { int[] arr = {1,2,3}; func(arr); System.out.println(“arr[0] = ” + arr[0]); } 
public static void func(int[] a) {
    a[0] = 10;
    System.out.println("a[0] = " + a[0]);
}

}

![image.png](#clientId=u296f67bb-fb04-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=98&id=u12553f3c&margin=%5Bobject%20Object%5D&name=image.png&originHeight=101&originWidth=348&originalType=binary&ratio=1&rotation=0&showTitle=false&size=7100&status=done&style=none&taskId=u38f0bb07-560b-4922-aa77-5a065be8101&title=&width=337.99998474121094)
<a name="AggJi"></a>
#### 数组作为函数的回来值
```java
import java.util.Arrays;
public class Demo_arr2 {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int[] ret = func2(array);
        System.out.println(Arrays.toString(ret));
    }
    //将数组a里边的元素扩展两倍，并回来，不改变原有的数组
    public static int[] func2(int[] a) {
        int[] tmp = new int[a.length];
        for (int i = 0;i < a.length; ++i) {
            tmp[i] = a[i] * 2;
        }
        return tmp;
    }
}

数组操练

1. 数组转字符串
import java.util.Arrays;
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);
//执行成果
[1,2,3,4,5,6]
2. 数组复制
import java.util.Arrays;
public class Demo1 {
    // 数组复制
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6};
        // newArr和arr引证的是同一个数组
        int[] newArr = arr;
        newArr[0] = 100;
        System.out.println("newArr: " + Arrays.toString(arr));
        // 运用Arrays中copyOf办法完结数组的复制
        // copyOf办法在进行数组复制时，创立了一个新数组
        arr[0] = 1;
        // arr和newArr引证的不是同一个数组
        newArr = Arrays.copyOf(arr,arr.length);
        System.out.println("newArr: " + Arrays.toString(newArr));
        // 修正arr引证的内容时，对newArr没有影响
        arr[0] = 90;
        System.out.println("arr: " + Arrays.toString(arr));
        System.out.println("newArr: " + Arrays.toString(newArr));
        // 复制某个规模
        int[] newArr2 = Arrays.copyOfRange(arr,2,4);
        System.out.println("newArr2: " + Arrays.toString(newArr2));
    }
}

Java基础语法（一）

留意：数组傍边存储的是根本数据类型时，不管怎么复制根本都不会呈现什么问题，但假如存储的是引证数据类型时，复制时需求考虑深浅复制的问题，这样今后细说。

完成自己版其他复制数组：

// 完成自己版其他复制数组
public static int[] myCopyOf(int[] arr) {
    int[] ret = new int[arr.length];
    for (int i = 0; i < arr.length; ++i) {
        ret[i] = arr[i];
    }
    return ret;
}
3. 求数组中元素的平均值
// 求数组中元素的平均值
public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6,7};
    System.out.println(avg(arr));
}
public static double avg(int[] arr) {
    int sum = 0;
    for (int x : arr) {
        sum += x;
    }
    return (double)sum / (double)arr.length;
}

Java基础语法（一）

4. 查找数组中指定元素（顺序查找）
// 查找数组中指定元素（顺序查找）
public static int find(int[] arr, int data) {
    for (int i = 0; i < arr.length; ++i) {
        if (arr[i] == data) {
            return i;
        }
    }
    return -1;
}
public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6,7};
    System.out.println(find(arr,3));
    System.out.println(find(arr,0));
}

Java基础语法（一）

5. 查找数组中指定元素（二分查找）
// 二分查找
public static int binarySearch(int[] arr, int data) {
    int left = 0;
    int right = arr.length-1;
    while (left <= right) {
        int mid = left + (right >> 1);
        if (arr[mid] > data) { //到左半区间找
            right = mid - 1;
        } else if (arr[mid] < data) { // 到右半区间找
            left = mid + 1;
        } else {
            return mid; //找到了
        }
    }
    return -1; //代表没找到
}
public static void main(String[] args) {
    int[] arr = {1,2,3,4,5,6};
    System.out.println(binarySearch(arr,6));
}

Java基础语法（一）

6. 冒泡排序
// 冒泡排序
public static void bubbleSort(int[] arr) {
    for (int i = 0; i < arr.length; ++i) {
        // 每一趟排序后，最大值都会跑到数组的最末端
        for (int j = 1; j < arr.length - i; ++j) {
            if (arr[j-1] > arr[j]) {
                int tmp = arr[j-1];
                arr[j-1] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}
public static void main(String[] args) {
    int[] arr = {9,5,2,7};
    bubbleSort(arr);
    System.out.println(Arrays.toString(arr));
}

Java基础语法（一）

冒泡排序性能较低，java中内置了更高效的排序算法：

public static void main(String[] args) {
    //java中更高效的排序算法
    int[] arr = {9,5,2,7};
    Arrays.sort(arr);
    System.out.println(Arrays.toString(arr));
}
7. 数组逆序
// 数组逆序
public static void reverse(int[] arr) {
    int left = 0;
    int right = arr.length - 1;
    while (left < right) {
        int tmp = arr[left];
        arr[left] = arr[right];
        arr[right] = tmp;
        ++left;
        --right;
    }
}
public static void main(String[] args) {
    int[] arr = {1,2,3,4,5};
    reverse(arr);
    System.out.println(Arrays.toString(arr));
}

Java基础语法（一）

二维数组

根本语法：数据类型[][] 数组称号 = new 数据类型 [行数][列数] {初始化数据};
代码示例：

// 二维数组
public static void main(String[] args) {
    int[][] arr = {
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}
    };
    for (int row = 0; row < arr.length; ++row) {
        for (int col = 0; col < arr[row].length; ++col) {
            System.out.print(arr[row][col] + "\t");
        }
        System.out.println();
    }
}

Java基础语法（一）

Java基础语法（一）

打印二维数组的办法Arrays.deeptoString();

int[][] arr = {
    {1,2,3,4},
    {5,6,7,8},
    {9,10,11,12}
};
// 打印二维数组的办法
System.out.println(Arrays.deepToString(arr));

Java基础语法（一）

不规则的二维数组：

// 不规则的二维数组
public static void main(String[] args) {
    int[][] array = new int[2][];
    // 留意：C言语 是能够指定列，行能够主动推导
    // Java中，行有必要指定，列不能够主动推导
    array[0] = new int[3]; // 第一行有三列
    // 也能够进行初始化：array[0] = new int[]{1,2,3};
    array[1] = new int[2]; // 第二行有两列
}

Java基础语法（一）

6. 常量

6.1 字面值常量

Java基础语法（一）

6.2 final 关键字润饰的常量

// 常量只能被初始化一次，且运用的时分一定要记得初始化
public static void main (String[] args) {
    // 界说常量，主张称号全大写
    final int MAXNUM = 10;
    System.out.println(MAXNUM);
}

常量不能在程序运转过程中发生修正。


# 7. int 和 String 之间的相互转化 ## 7.1 int 转成 String “`java int num = 10; //办法1： String str1 = num + “”; //办法2： String str2 = String.valueOf(num); “` ## 7.2 String 转成 int “`java String str = “100”; int num = Integer.parseInt(str);

//假如字符串包括除数字外其他东西，则报错 Stringstr2 = “100abc”; int num2 = Integer.parseInt(str2); //报错


<a name="uvx9U"></a>
# 8. 运算符
这里没什么好说的，跟C言语的差不多。此处只提及Java与C言语不同的部分。
- % 不只能够对整型取模，还能够对double类型取模，可是没有意义，一般对整型取模。
```java
System.out.println(11.5 % 2.0);
//运转成果
1.5
  • 自增或自减运算符
int i = 10;
i = i++;
//输出10，这个跟C言语不同
System.out.println(i);

详细原因今后再讨论。

9. 程序逻辑控制

9.1 switch 句子

switch 语法根本和C言语共同，下面给出示例：

int day = 1;
switch(day) {
    case 1:
        System.out.println("1");
        break;
    case 2:
        System.out.println("2");
        break;
    default:
        System.out.println("输入有误");
        break;
}

【留意事项】：

  1. 多个case后的常量值不能够重复。
  2. switch的括号内只能是以下类型的表达式：
    • 根本类型：byte，char，short，int，char，留意不能是long，float，double，boolean
    • 引证类型：String常量串，枚举类型

过错示例：

Java基础语法（一）

Java基础语法（一）

9.2 补充

像for``while的循环条件表达式只能为**布尔类型的，**像下面的代码便是过错的：

if (1) {
}
while (1) {
}

10. 办法的概念和运用

办法简而言之便是一个功能函数

10.1 办法界说

语法格局：

润饰符 回来值类型 办法称号(参数列表) {
    办法体代码;
    回来值;
}

【留意事项】：

  1. 润饰符：现阶段直接运用public static固定调配。

原因：由于当时所有的办法 写完之后 会在main办法中调用，由于main办法是public static的。静态的main函数里边只能调用静态的办法。

  1. 办法姓名：选用小驼峰命名。
  2. 在Java中，办法有必要写在类傍边。
  3. 在Java中，办法不能嵌套界说。
  4. 在Java中，没有办法声明一说，你的办法界说在main的上面或下面都无所谓。

## 10.2 实参和形参的关系 **在Java中，实参的值永远都是复制到形参中，形参和实参本质是两个实体。（这点跟C言语不相同，C言语能够传递地址，来改变实参的值，可是Java只能改变形参的值）。**

解决办法：传引证类型的参数（例如数组）
示例：

public class Demo {
    public static void main(String[] args) {
        int[] arr = {10,20};
        swap(arr);
        System.out.println("arr[0] = " + arr[0] + " arr[1] = " + arr[1]);
    }
    public static void swap(int[] arr) {
        int tmp = arr[0];
        arr[0] = arr[1];
        arr[1] = tmp;
    }
}
//运转成果
arr[0] = 20 arr[1] = 10

# 11. 办法的重载 **重载即是“一词多义”的意思。**
**在Java中，假如多个办法的姓名相同，参数列表不同，则称该几种办法被重载了。**

示例：

public class Demo2 {
    // 办法的重载
    public static int maxNum(int a, int b) {
        return a > b ? a : b;
    }
    public static double maxNum(double a, double b) {
        return a > b ? a : b;
    }
    public static int maxNumOf3(int a, int b, int c) {
        return maxNum(maxNum(a,b),c);
    }
    public static double maxNumOf3(double a, double b, double c) {
        return maxNum(maxNum(a,b),c);
    }
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 40;
        System.out.println(maxNumOf3(a,b,c));
        double d1 = 2.134;
        double d2 = -1.739;
        double d3 = 9.087;
        System.out.println(maxNumOf3(d1,d2,d3));
    }
}

【留意事项】：

  1. 办法名有必要相同。
  2. 参数列表有必要不同（参数的个数不同、参数的类型不同、类型的次序有必要不同）
  3. 与回来值类型是否相同无关。

示例：

public class Demo2 {
    // 办法的重载
    public static int maxNum(int a, int b) {
        return a > b ? a : b;
    }
    //仅仅是回来类型不同，无法构成重载
    public static double maxNum(int a, int b) {
        return a > b ? a : b;
    }
    public static void main(String[] args) {
    }
}
  1. 编译器在编译代码时，会对实参类型进行推演，依据推演的成果来确认调用哪个办法。

# 12. 办法签名 在同一个效果域中不能界说两个相同称号的标识符。如，办法中不能界说两个姓名相同的变量，那**为什么类中就能够界说办法名相同的办法呢？**

办法签名：通过编译器编译修正之后办法的终究的姓名。详细办法：办法全途径名+参数列表+回来值类型，构成办法的完好的姓名。
（类似于C++中函数重载中，生成的润饰名会依据函数参数的不同而不同）