java基础

一.Java语言跨平台原理

Java程序并非是直接运行的，Java编译器将Java源程序编译成与平台无关的字节码文件(class文件)，然后由Java虚拟机（JVM）对字节码文件解释执行。所以在不同的操作系统下，只需安装不同的Java虚拟机即可实现java程序的跨平台。

所谓的“一次编写，到处运行”（Write once, run anywhere），能够非常容易地获得跨平台能力。跟c/c++最大的不同点在于，c/c++编程是面向操作系统的，需要开发者极大地关心不同操作系统之间的差异性；而Java平台通过虚拟机屏蔽了操作系统的底层细节，使得开发者无需过多地关心不同操作系统之间的差异性。

通过增加一个间接的中间层来进行”解耦“是计算机领域非常常用的一种”艺术手法“，虚拟机是这样，操作系统是这样；

能够到处运行的实现原理：Java程序是通过虚拟机在系统平台上运行的，只要该系统安装相应的java虚拟机，该系统就可以运行java程序。

虚拟机和垃圾收集:Java虚拟机和垃圾收集（GC, Garbage Collection），Java 通过垃圾收集器（Garbage Collector）回收分配内存，大部分情况下，程序员不需要自己操心内存的分配和回收。

程序编译原理：什么是字节码？采用字节码的最大好处是什么

字节码：Java源代码经过虚拟机编译器编译后产生的文件（即扩展为.class的文件），它不面向任何特定的处理器或操作系统，只面向虚拟机。

 

采用字节码的好处：

Java语言通过字节码的方式，在一定程度上解决了传统解释型语言执行效率低的问题，同时又保留了解释型语言可移植的特点。所以Java程序运行时比较高效，而且，由于字节码并不面向任何特定的处理器或操作系统，因此，Java程序无须重新编译便可在多种不同的计算机上运行。

先看下java中的编译器和解释器：

Java源程序经过编译器编译后变成字节码，字节码由虚拟机解释执行，虚拟机将每一条要执行的字节码送给解释器，解释器将其翻译成特定机器上的机器码，然后在特定的机器上运行

Java源代码---->编译器---->jvm可执行的Java字节码(即虚拟指令)---->jvm---->jvm中解释器----->机器可执行的二进制机器码---->程序运行。 

 二.JVM、JRE和JDK的关系

JVM

Java Virtual Machine是Java虚拟机，Java程序需要运行在虚拟机上，不同的平台有自己的虚拟机，因此Java语言可以实现跨平台。

JRE

Java Runtime Environment包括Java虚拟机和Java程序所需的核心类库等。核心类库主要是java.lang包：包含了运行Java程序必不可少的系统类，如包装类型、基本数学函数、字符串处理、线程、异常处理类等，系统缺省加载这个包。如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

JDK

Java Development Kit是提供给Java开发人员使用的，其中包含了Java的开发工具，也包括了JRE。所以安装了JDK，就无需再单独安装JRE了。其中的开发工具：编译工具(javac.exe)，打包工具(jar.exe)等

JVM&JRE&JDK关系图

 三.常用DOS命令

在接触集成开发环境之前，我们需要使用命令行窗口对java程序进行编译和运行，所以需要知道一些常用DOS命令。

1、打开命令行窗口的方式：win + r打开运行窗口，输入cmd，回车。

2、常用命令及其作用

操作	说明
盘符名称:	盘符切换。E:回车，表示切换到E盘。
dir	查看当前路径下的内容。
cd 目录	进入单级目录。cd itheima
cd ..	回退到上一级目录。
cd 目录1\目录2...	进入多级目录。cd itheima\JavaSE
cd \	回退到盘符目录。
cls	清屏。
exit	退出命令提示符窗口。

 

四.基础语法

4.1 基本数据类型

四类八种

数据类型	关键字	内存占用	取值范围
整数类型	byte	1	-128~127
	short	2	-32768~32767
	int(默认)	4	-2的31次方到2的31次方-1
	long	8	-2的63次方到2的63次方-1
浮点类型	float	4	负数：-3.402823E+38到-1.401298E-45 正数： 1.401298E-45到3.402823E+38
	double(默认)	8	负数：-1.797693E+308到-4.9000000E-324 正数：4.9000000E-324 到1.797693E+308
字符类型	char	2	0-65535
布尔类型	boolean	1	true，false

 4.2 标识符（理解）

标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。

Java中标识符的组成规则：

1. 由字母、数字、下划线“_”、美元符号“$”组成，第一个字符不能是数字。
2. 不能使用java中的关键字作为标识符。
3. 标识符对大小写敏感（区分大小写）。

Java中标识符的命名约定：

小驼峰式命名：变量名、方法名

首字母小写，从第二个单词开始每个单词的首字母大写。

大驼峰式命名：类名

每个单词的首字母都大写。

另外，标识符的命名最好可以做到见名知意

例如：username、studentNumber等。

4.3类型转换

4.3.1.隐式转换

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量。这种转换方式是自动的，直接书写即可。

注:整数默认是int类型，byte、short和char类型数据参与运算均会自动转换为int类型。

4.3.2.强制转换

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量。

强制类型转换格式：目标数据类型 变量名 = (目标数据类型)值或者变量;
double num1 = 5.5;
int num2 = (int) num1; // 将double类型的num1强制转换为int类型
System.out.println(num2); // 输出5（小数位直接舍弃）

 注:常量优化机制:在编译时，整数常量的计算会直接算出结果，并且会自动判断该结果是否在byte取值范围内，

五.运算符

5.1 算数运算符

符号	作用	说明
+	加	参看小学一年级
-	减	参看小学一年级
*	乘	参看小学二年级，与“×”相同
/	除	参看小学二年级，与“÷”相同
%	取余	获取的是两个数据做除法的余数

 

5.2自增自减运算符

符号	作用	说明
++	自增	变量的值加1
--	自减	变量的值减1

5.3赋值运算符

赋值运算符的作用是将一个表达式的值赋给左边，左边必须是可修改的，不能是常量。

=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-=	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

注意：

扩展的赋值运算符隐含了强制类型转换。

short s = 10;
s = s + 10; // 此行代码报出，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度

s += 10; // 此行代码没有问题，隐含了强制类型转换，相当于 s = (short) (s + 10);

5.4 关系运算符

符号	说明
==	a==b，判断a和b的值是否相等，成立为true，不成立为false
!=	a!=b，判断a和b的值是否不相等，成立为true，不成立为false
>	a>b，判断a是否大于b，成立为true，不成立为false
>=	a>=b，判断a是否大于等于b，成立为true，不成立为false
<
<=

注意事项：

关系运算符的结果都是boolean类型，要么是true，要么是false。

5.5 逻辑运算符

符号	作用	说明
&	逻辑与	a&b，a和b都是true，结果为true，否则为false
|	逻辑或	a|b，a和b都是false，结果为false，否则为true
^	逻辑异或	a^b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反

5.6 短路逻辑运算符

符号	作用	说明
&&	短路与	作用和&相同，但是有短路效果
||	短路或	作用和|相同，但是有短路效果

在逻辑与运算中，只要有一个表达式的值为false，那么结果就可以判定为false了，没有必要将所有表达式的值都计算出来，

短路与操作就有这样的效果，可以提高效率。同理在逻辑或运算中，一旦发现值为true，右边的表达式将不再参与运算。

• 逻辑与&，无论左边真假，右边都要执行。
• 短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
• 逻辑或|，无论左边真假，右边都要执行。
• 短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。

5.7 三元运算符

格式:关系表达式 ? 表达式1 : 表达式2;

六.流程控制语句

6.1顺序结构

6.2分支结构(if, switch)

6.2.1 if语句

格式：
if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}

6.2.2 switch语句

switch (表达式) {
	case 1:
		语句体1;
		break;
	case 2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;
}

switch语句case穿透:如果switch语句中,case省略了break语句, 就会开始case穿透.

现象：

当开始case穿透，后续的case就不会具有匹配效果，内部的语句都会执行

直到看见break，或者将整体switch语句执行完毕，才会结束。

public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入星期数:");
		int week = sc.nextInt();
		
		switch(week){
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("工作日");
				break;
			case 6:
			case 7:
				System.out.println("休息日");
				break;
			default:
				System.out.println("您的输入有误");
				break;
		}
	}	
}
//

6.3循环结构(for, while, do…while)

6.3.1 for循环

for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
}

6.3.2 while 循环

初始化语句;
while(条件判断语句){
	循环体语句;
	条件控制语句;
};

6.3.3 do...while循环

初始化语句;
do {
	循环体语句;
	条件控制语句;
}while(条件判断语句);

6.3.4 跳出循环

跳转控制语句（break）
跳出循环，结束循环
跳转控制语句（continue）
跳过本次循环，继续下次循环
注意： continue只能在循环中进行使用！

七 .一维数组

7.1数组的定义格式

第一种:
    int[] arr; 
第二种:
    int arr[];

7.2 数组初始化

7.2.1 动态初始化

package com.itheima.array;

public class Demo2Array {
    /*
        数组的动态初始化:
                        在初始化的时候, 需要手动指定数组的长度, 系统会为数组容器分配初始值.

        动态初始化格式:
                        数据类型[] 数组名 = new 数据类型[数组的长度];

        注意:
                        打印数组变量的时候, 会打印出数组的内存地址

        [I@10f87f48 :

                        @ : 分隔符
                        [ : 当前的空间是一个数组类型
                        I : 当前数组容器中所存储的数据类型
                        10f87f48 : 十六进制内存地址

                                0 1 2 3 4 5 6 7 8 9 a b c d e f
     */
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[数组的长度];
        // 通过new关键字创建了一个int类型的数组容器, 该容器可以存储5个int类型的整数, 该容器被arr数组变量所记录
        int[] arr = new int[5];
        // [I@10f87f48
        System.out.println(arr);

        byte[] bArr = new byte[3];
        // [B@b4c966a
        System.out.println(bArr);

    }
}

7.2.2 静态初始化

在创建数组时，直接将元素确定

package com.itheima.array2;

public class Demo1Array {
    /*
        数组静态初始化 : 初始化时指定每个数组元素的初始值，由系统决定数组长度

        完整格式:
                    数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
        简化格式:
                    数据类型[] 数组名 = {数据1,数据2,数据3...};
     */
    public static void main(String[] args) {
        // 数据类型[] 数组名 = new 数据类型[]{数据1,数据2,数据3...};
        int[] arr = new int[]{11,22,33};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);

        // 数据类型[] 数组名 = {数据1,数据2,数据3...};
        int[] arr2 = {44,55,66};
        System.out.println(arr2);
        System.out.println(arr2[0]);
        System.out.println(arr2[1]);
        System.out.println(arr2[2]);

    }
}

7.3 内存分配

内存概述:

内存是计算机中的重要原件，临时存储区域，作用是运行程序。

我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的。

必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

java中的内存分配:

区域名称	作用
寄存器	给CPU使用，和我们开发无关。
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区内存	存储可以运行的class文件。
堆内存	存储对象或者数组，new来创建的，都存储在堆内存。
方法栈内内存	方法运行时使用的内存，比如main方法运行，进入方法栈中执行。

 

7.4 数组操作的两个常见问题

7.4.1 索引越界异常

ArrayIndexOutOfBoundsException 数组越界异常

7.4.2 空指针异常

NullPointerException 空指针异常

八 . 二维数组

概述 : 二维数组也是一种容器，不同于一维数组，该容器存储的都是一维数组容器

8.1 二维数组动态初始化

动态初始化格式：
数据类型[][] 变量名 = new 数据类型[m][n];
m表示这个二维数组，可以存放多少个一维数组
n表示每一个一维数组，可以存放多少个元素

package com.itheima.demo;
public class Demo1Array {

public static void main(String[] args) {
// 数据类型[][] 变量名 = new 数据类型[m][n];
int[][] arr = new int[3][3];
/*
[[I@10f87f48
@ : 分隔符
10f87f48 : 十六进制内存地址
I : 数组中存储的数据类型
[[ : 几个中括号就代表的是几维数组
*/
System.out.println(arr);
/*
二维数组存储一维数组的时候, 存储的是一维数组的内存地址
*/

问题 : 二维数组中存储的是一维数组, 那能不能存入 [提前创建好的一维数组] 呢 ? 答 : 可以的,二维数组存储一维数组的时候, 存储的是一维数组的内存地址

8.2 二维数组静态初始化

完整格式 : 数据类型[][] 变量名 = new 数据类型[][]{ {元素1, 元素2...} , {元素1, 元素2...}
简化格式 : 数据类型[][] 变量名 = { {元素1, 元素2...} , {元素1, 元素2...} ...};

ackage com.itheima.demo;
public class Demo3Array {

public static void main(String[] args) {
         int[] arr1 = {11,22,33};
         int[] arr2 = {44,55,66};
         int[][] arr = {{11,22,33}, {44,55,66}};

        System.out.println(arr[0][2]);
        int[][] array = {arr1,arr2};
        System.out.println(array[0][2]);
}
}

九. 方法

9.1 方法的概念

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

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

9.2 方法的定义和调用

定义格式：

//无参无返回值
public static void 方法名 (   ) {
	// 方法体;
}

//有参有返回值
public static 返回值类型 方法名(参数) {
   方法体; 
   return 数据 ;
}


/*注意：
	方法必须先定义，后调用，否则程序将报错
 */

方法的调用过程:

总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失。

9.3 方法的注意事项

1. 方法不能嵌套定义

   public class MethodDemo {
       public static void main(String[] args) {
   
       }
   
       public static void methodOne() {
   		public static void methodTwo() {
          		// 这里会引发编译错误!!!
       	}
       }
   }

2. void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据.

9.4 方法的重载

• 方法重载概念方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
  • 多个方法在同一个类中
  • 多个方法具有相同的方法名
  • 多个方法的参数不相同，参数的类型不同或者参数的数量不同
• 注意：
  • 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
  • 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，换句话说不能通过返回值来判定两个方法是否相互构成重载

注意：方法可以重载，但一个类里面不能出现相同的两个方法。（方法相同包括方法名相同，参数顺序、类型相同。与参数名称和返回值类型无关）

9.5 方法的参数传递

• 1. 基本数据类型的参数，形式参数的改变，不影响实际参数 . 原因：每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失
  2. 对于引用类型的参数，形式参数的改变，影响实际参数的值 . 原因：引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，所以即使方法弹栈，堆内存中的数据也已经是改变后的结果