黑马学习笔记--JAVA基础知识

JAVA概述

JAVA发展史：

JAVA之父：詹姆斯.高斯林

SUN公司：斯坦福大学网络公司（2010-10-24被oracle收购）

JDK JRE JVM：

JDK: JAVA开发工具包，包含了JRE,编译工具，打包工具等。（安装了JDK就不用安装JRE了）。

JRE：JAVA运行环境，包含了核心类库和JVM。

JVM：JAVA虚拟机，JAVA程序需要运行在虚拟机上，虚拟机有各种平台的，因此JAVA语言可以跨平台。

注释概述

注释：

用于解释说明程序的文字。

注释分类：

单行注释:

//

多行注释:

/*   */

文本注释:

/**    */

作用：

解释说明程序，帮助我们调试错误。

关键字

被JAVA语言赋予特定含义的单词。

特点：

字母全部小写，编译器颜色标记

语法格式

常量

常量概述：

在程序执行过程中，其值不能发生改变。

常量分类：

字符串常量 - 双引号引起来

整数常量 - 所有整数

小数常量 - 所有小数

字符常量 - 单引号引起来

布尔常量 - true false

空常量 - null

变量

变量概述：

在程序执行过程中，在某个范围内，其值可以发生改变。

本质：

内存中的一小块区域

定义格式：

数据类型 变量名 = 初始化值

数据类型

计算机存储单元

计算机存储设备的最小信息单元叫“位（bit）”

计算机最小的存储单元叫“字节（byte）” 一般用B表示。

1B = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

1PB = 1024TB

1EB = 1024PB

数据类型概述和分类

分为基本数据类型和引用数据类型

基本数据类型：四类八种

四类	八种	字节数	数据表示范围
整	byte	1	-128～127
	short	2	-32768~32767
	int	4	-2147483648~2147483648
型	long	8	-2^63~2^63-1
浮点	float	4	-3.403E38～3.403E38
型	double	8	-1.798E308～1.798E308
字符型	char	2	表示一个字符如’2’
布尔型	boolean	1	true or false

- 需要记忆的: ‘A’ = 65; ‘a’ = 97; ‘0’ = 48;

标识符

作用：

给包，类，方法，变量等起名字。

组成规则：

由字符，下划线，$组成。

注意事项：

不能以数字开头

不能是关键字

命名原则：

见名知意

定义变量

定义格式：

数据类型 变量名 = 初始化值

注意：

整数默认是int类型，定义long类型要加L

变量未赋值不能直接使用

变量只在她所属范围内有效

一行可以定义多个变量 但是不建议

数据类型转换

隐式数据类型转换：

取值范围小的数据类型与取值范围大的数据类型进行运算,会先将小的数据类型提升为大的,再运算。

强制数据类型转换：

强制转换格式： b = (byte)(a + b);

注意事项：

如果超出了被赋值的数据类型的取值范围得到的结果会与你期望的结果不同

运算符

对常量和变量进行操作的符号成为运算符

用运算符把常量或者变量连接起来符号java语法的式子就可以称为表达式

常用运算符：算术运算符 关系运算符 赋值运算符 逻辑运算符 三元运算符

算术运算符：

取余和除法的区别

%：取余运算符。得到的是两个相除数据的余数。

/:除法运算符。得到是两个相除数据的商

++ –详解

++,–运算符：对变量做加1或者减1的操作。

++或者–既可以放在变量的后面，也可以放在变量的前面。

单独使用的时候，++或者–无论是放在变量的前面还是后面，结果是一样的。

参与操作的时候：

如果++或者–在变量的后面，先拿变量参与操作，后变量做++或者–

如果++或者–在变量的前面，先变量做++或者–，后拿变量参与操作。

赋值运算符：

基本的赋值运算符：=

扩展的赋值运算符：+=,-=,* =,/=,%=

+=: a+=20;相当于a = (a的数据类型)(a + 20)

关系运算符：

==,!=,>,>=,<,<=

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

逻辑运算符：

&,|,^,!,&&,||

注意事项：

逻辑运算符一般用于连接boolean类型的表达式或者值。

表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。

算术表达式：a + b

比较表达式：a == b(条件表达式)

总结：

运用：

&逻辑与:有false则false。

|逻辑或:有true则true。

^逻辑异或:相同为false，不同为true。

!逻辑非:非false则true，非true则false。

&&与&的区别：

最终结果一样。

&&具有短路效果。左边是false，右边不执行。

&是无论左边是false还是true,右边都会执行

||和|的区别：

最终结果一样

||具有短路效果.左边是true,右边不执行

|是无论左边是false还是true,右边都会执行

三元运算符：

关系表达式)?表达式1：表达式2；

如果条件为true，运算后的结果是表达式1；

如果条件为false，运算后的结果是表达式2；

简单的键盘录入：

import java.util.Scanner;   //导包
public class ScannerTest {
public static void main(String[] args) {
// 创建对象
Scanner sc = new Scanner(System.in);

// 接收数据
System.out.println("请输入第一个数据：");
int a = sc.nextInt();

System.out.println("请输入第二个数据：");
int b = sc.nextInt();

// 对数据进行求和
int sum = a + b;
System.out.println("sum:" + sum);
}
}

选择流程控制语句

顺序结构概述：

是程序中最简单最基本的流程控制，没有特定的语法结构，依照代码的先后顺序，依次执行，程序中大多数代码都是这样执行的。

if语句的格式

格式一

if(关系表达式){语句体}

格式二

if(关系表达式){语句体}else(语句体)

格式三

if(关系表达式){语句体}else if(关系表达式){语句体}else{语句体}

if语句实现获取三个数据排列顺序

1.键盘录入三个整数，按照从小到大的顺序输出

2.如果用户输入的是3 2 1，程序运行后打印格式”按照从小到大排序后的顺序为：1 2 3”

import java.util.*;
public static void main(String[] args){
Scanner s = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int a = s.nextInt();
System.out.println("请输入第二个整数：");
int b = s.nextInt();
System.out.println("请输入第三个整数：");
int  c = s.nextInt();
int temp;
if(a < b){
temp = a;
a = b;
b = temp;
}
if(a < c){
temp = a;
a = c;
c = temp;
}
if(b < c){
temp = b;
b = c;
c = temp;
}
System.out.println(c+"-->"+b+"-->"+a);
}

switch语句的格式

格式:

swith(表达式){
case 值1:
语句体;
break;
case 值2:
语句体;
break;
default:
语句体;
break;
}
```
### 格式解释:
- switch表示这是switch语句
- 表达式的取值：byte,short,int,char,String (不能取小数)
- JDK5以后可以是枚举
- JDK7以后可以是String
- case后面跟的是要和表达式进行比较的值
- 语句体部分可以是一条或多条语句
- break表示中断，结束的意思，可以结束switch语句
- default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
### 执行流程:
首先计算出表达式的值
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

### 例句:
``` JAVA
public class SwitchDemo {
public static void main(String[] args) {
//创建键盘录入对象
Scanner sc = new Scanner(System.in);

//接收数据
System.out.println("请输入一个数字(1-7)：");
int weekday = sc.nextInt();

//switch语句实现选择
switch(weekday) {
case 1:
System.out.println("星期一");
break;
case 2:
System.out.println("星期二");
break;
case 3:
System.out.println("星期三");
break;
case 4:
System.out.println("星期四");
break;
case 5:
System.out.println("星期五");
break;
case 6:
System.out.println("星期六");
break;
case 7:
System.out.println("星期日");
break;
default:
System.out.println("你输入的数字有误");
break;
}
}
}

<div class="se-preview-section-delimiter"></div>

循环流程控制语句

for循环格式和基本使用

格式:

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

循环体语句;

}

执行流程：

A:执行初始化语句

B:执行判断条件语句，看其结果是true还是false

如果是false，循环结束。

如果是true，继续执行。

C:执行循环体语句

D:执行控制条件语句

E:回到B继续

案例:

public class ForDemo {
public static void main(String[] args) {
//原始写法
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("-------------------------");
//用循环改进
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
}
}

<div class="se-preview-section-delimiter"></div>

while循环语句格式

格式:

基本格式
while(判断条件语句) {
循环体语句;
}
扩展格式
初始化语句;
while(判断条件语句) {
循环体语句;
控制条件语句;
}

<div class="se-preview-section-delimiter"></div>

public class WhileTest {
public static void main(String[] args) {
//回顾for循环实现
/*
//定义求和变量
int sum = 0;
//获取1-100之间的数据
for(int x=1; x<=100; x++) {
//累加
sum += x;
}
System.out.println("1-100的和是："+sum);
*/
//while循环实现
//定义求和变量
int sum = 0;
int x = 1;
while(x<=100) {
sum += x;
x++;
}
System.out.println("1-100的和是："+sum);
}
}

<div class="se-preview-section-delimiter"></div>

do…while循环的格式及基本使用

格式:

基本格式
do {
循环体语句;
}while(判断条件语句);
扩展格式
初始化语句;
do {
循环体语句;
控制条件语句;
} while(判断条件语句);

<div class="se-preview-section-delimiter"></div>

案例:

public class DoWhileDemo {
public static void main(String[] args) {
//输出10次 HelloWorld
/*
for(int x=1; x<=10; x++) {
System.out.println("HelloWorld");
}
*/

//do...while改写
int x=1;
do {
System.out.println("HelloWorld");
x++;
}while(x<=10);
}
}

<div class="se-preview-section-delimiter"></div>

三种循环的区别:

do…while循环至少会执行一次循环体。

for循环和while循环只有在条件成立的时候才会去执行循环体

for循环语句和while循环语句的小区别：

使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。

案例:

/*
* 三种循环的区别：
*      A:do...while至少执行一次循环体
*      B:for,while循环先判断条件是否成立，然后决定是否执行循环体
*
* for和while的小区别：
*      for循环的初始化变量，在循环结束后，不可以被访问。而while循环的初始化变量，是可以被继续使用的。
*      如果初始化变量，后面还要继续访问，就使用while，否则，推荐使用for。
*
* 循环的使用推荐：
*      for -- while -- do...while
*/
public class DoWhileDemo2 {
public static void main(String[] args) {
/*
int x = 3;
while(x<3) {
System.out.println("我爱林青霞");
x++;
}
System.out.println("--------------");
int y = 3;
do {
System.out.println("我爱林青霞");
y++;
}while(y<3);
*/
for(int x=1; x<=10; x++){
System.out.println("爱生活，爱Java");
}
//这里的x无法继续访问
//System.out.println(x);
System.out.println("-----------------");

int y = 1;
while(y<=10) {
System.out.println("爱生活，爱Java");
y++;
}
System.out.println(y);
}
}

<div class="se-preview-section-delimiter"></div>

控制循环语句

break的使用

break的使用场景和作用：

break的使用场景：在选择结构switch语句中。

在循环语句中，离开使用场景的存在是没有意义的。

break的作用：跳出单层循环。

案例：

public class BreakDemo {
public static void main(String[] args) {
//break;

for(int x=1; x<=10; x++) {
if(x == 3) {
break;
}
System.out.println("HelloWorld");
}
}
}

<div class="se-preview-section-delimiter"></div>

continue的使用

continue的使用场景和作用:

continue的作用：单层循环对比break。

案例:

public class ContinueDemo {
public static void main(String[] args) {
//continue;

for(int x=1; x<=10; x++) {
if(x == 3) {
//break;
continue;
}
System.out.println("HelloWorld");
}
}
}

<div class="se-preview-section-delimiter"></div>

总结：

break退出当前循环

continue退出本次循环

- return退出当前方法

Random讲解

使用步骤:

导包:import java.util.Random;

创建对象:Random r = new Random();

获取随机数:int number = r.nextInt(10);

产生的数据在0到10之间，包括0，不包括10。

括号里面的10是可以变化的，如果是100，就是0-100之间的数据

案例:

import java.util.Random;
import java.util.Scanner;

/*
* 猜数字小游戏案例
*      系统产生一个1-100之间的随机数，请猜出这个数据是多少。
* 分析：
*      A:系统产生一个随机数1-100之间的。
*          int number = r.nextInt(100) + 1;
*      B:键盘录入我们要猜的数据
*          用Scanner实现
*      C:比较这两个数据(用if语句)
*          大了：给出提示大了
*          小了：给出提示小了
*          猜中了：给出提示，恭喜你，猜中了
*      D:多次猜数据，而我们不知道要猜多少次，怎么办呢?
*          while(true) {循环的内容}
*/
public class RandomTest {
public static void main(String[] args) {
// 系统产生一个随机数1-100之间的。
Random r = new Random();
int number = r.nextInt(100) + 1;

while(true){
// 键盘录入我们要猜的数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要猜的数字(1-100)：");
int guessNumber = sc.nextInt();

// 比较这两个数据(用if语句)
if (guessNumber > number) {
System.out.println("你猜的数据" + guessNumber + "大了");
} else if (guessNumber < number) {
System.out.println("你猜的数据" + guessNumber + "小了");
} else {
System.out.println("恭喜你,猜中了");
break;
}
}
}
}

<div class="se-preview-section-delimiter"></div>

数组

数组的定义

数组的概念:

数组是存储同一种数据类型多个元素的容器。

数组既可以存储基本数据类型，也可以存储引用数据类型。

定义格式:

格式1：数据类型[] 数组名;

格式2：数据类型 数组名[];

注意：这两种定义做完了，数组中是没有元素值的。

数组的初始化

初始化概述:

Java中的数组必须先初始化,然后才能使用。

所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

数组的初始化方式：

动态初始化:初始化时只指定数组长度，由系统为数组分配初始值

格式：

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

数组长度其实就是数组中元素的个数。

举例：

int[] arr = new int[3];

解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

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

public static void main(String[] args) {
//定义数组
int[] arr = {1,2,3};

//输出数组名和元素
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}

<div class="se-preview-section-delimiter"></div>

JVM的内存划分：

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

栈 存储局部变量

堆 存储new出来的东西

方法区 (面向对象进阶讲)

本地方法区 (和系统相关)

寄存器 (给CPU使用)

堆栈概述:

堆:

每个对象都有一个内存地址都有默认初始值:

byte,short,int,long默认值:0;

float,double:0.0;

char:\u0000;

引用类型:null;

boolean:false;

使用完毕会在垃圾回收器空闲的时候回收。

栈：

存储局部变量。

使用完毕立即被回收。

一维数组的使用

遍历方式：

for(int x=0; x<arr.length; x++) {
System.out.println(arr[x]);
}

<div class="se-preview-section-delimiter"></div>

取最值：

public class ArrayTest2 {
public static void main(String[] args) {
//定义数组
int[] arr = {12,98,45,73,60};
//定义参照物
int max = arr[0];
//遍历数组，获取除了0以外的所有元素，进行比较
for(int x=1; x<arr.length; x++) {
if(arr[x] > max) {
max = arr[x];
}
}
System.out.println("数组中的最大值是："+max);
}
}

<div class="se-preview-section-delimiter"></div>

二维数组的使用

格式:

- 定义格式:数据类型[][] 数组名;
- 初始化方式:
- 数据类型[][] 变量名 = new 数据类型[m][n];
- 数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
- 简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};

<div class="se-preview-section-delimiter"></div>

遍历:

for(int y=0; y<arr.length; y++) {
for (int x = 0; x < arr[y].length; x++) {
System.out.print(arr[y][x] + "  ");
}
System.out.println();
}

<div class="se-preview-section-delimiter"></div>

方法的概述及基本使用

方法：简单的说：方法就是完成特定功能的代码块

方法的格式：

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
函数体;
return 返回值;
}

修饰符 目前记住 public static

返回值类型 用于限定返回值的数据类型

方法名 一个名字，为了方便我们调用方法

参数类型 用于接收调用方法时传入的数据的类型

参数名 用于接收调用方法时传入的数据的变量

方法体 完成功能的代码

return 结束方法，把返回值带给调用者

定义方法注意事项:

返回值类型 明确功能结果的数据类型

参数列表 明确有几个参数，以及参数的类型

按照格式和两个明确来完成如下功能

调用方式:

单独调用：没有明确的返回值 比如void类型方法的调用

输出调用

赋值调用

方法的重载：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

方法重载特点：

与返回值类型无关，只看方法名和参数列表.

在调用时，虚拟机通过参数列表的不同来区分同名方法.

参数列表不同:参数个数或者参数类型不同.

参数传递：

方法的参数是基本类型的时候：形式参数的改变不影响实际参数。

形式参数：用于接收实际数据的变量

实际参数：实际参与运算的变量