三更草堂JAVASE基础

【已完结】Java基础入门-2020-IDEA版-通俗易懂–零基础入门必备-三更草堂

1 HelloWorld

创建java文件

创建一个扩展名为.java的文件。注意：注意看下是否隐藏了扩展名。

编写java代码

在刚刚创建的HelloWorld.java文件中编写如下代码：

public class HelloWorld {
	public static void main(String[] args){
		System.out.println("HelloWorld");
	}
}

编译运行代码

java文件所在目录打开命令行窗口，编译java文件生成class文件（javac 文件名包含扩展名），运行class文件（java 类名）。

范例如下：

javac HelloWorld.java

java HelloWorld

常见问题

1、非法字符问题。Java中的符号都是英文格式的。

2、大小写问题。Java语言对大小写敏感（区分大小写）。

3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。

4、main写错成mian

2JVM、JRE、JDK

JVM（Java Virtual Machine），Java虚拟机，java程序需要在jvm上运行

JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（可供我们直接使用的代码）

JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YMmU3J6B-1681564327338)(img\image-20200811220157647.png)]

作为一个Java开发者我们需要安装什么呢？JDK

JDK的安装和配置

JDK安装

傻瓜式安装，下一步即可。但默认的安装路径是在C:\Program Files下，建议修改到其他盘符，例如：D:\Program Files\Java\jdk1.8.0_162\

注意：安装路径不要包含中文或者空格等特殊字符（使用纯英文目录）。

验证

进入jdk安装目录的bin目录下，在该目录下打开控制台，输入java -version目录进行测试

如果出现类似如图效果即算安装成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7wLH0zXl-1681564327343)(D:/工作/个人脑图/课程/课程资料/讲义/JavaSE/img/image-20200810222448576.png)]

环境变量配置

为了让我们在任意目录下都可以使用jdk提供的开发工具。我们需要把这些工具所在的目录配置到环境变量中。

配置JAVA_HOME系统变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oeYxIvyh-1681564327344)(img\image-20200812070406801.png)]

配置Path环境变量再最前面加上： %JAVA_HOME%\bin

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1e3X0MsM-1681564327345)(img\image-22220812070531763.png)]

配置完成后我们在任意目前下打开控制台都可以去使用jdk中自带的一些开发工具了。

3Random-生成随机数

我们可以通过 Random 类来生成随机数。

使用步骤

由于目前相关语法还没学习，所以先把步骤记住。后面学习了相关语法再来讲解。

1、导包。在定义类的上面写上下面的语句。

import java.util.Random；

2、创建对象

Random r = new Random();

3、生成随机数

int num = r.nextInt(10);//[0,9]

演示：

//导包
import java.util.Random;
public class RandomDemo {
    public static void main(String[] args) {
        Random r = new Random();
        int num = r.nextInt(10)+ 1;//[1,10]
        System.out.println(num);
    }
}

4Scanner-键盘录入数据

我们可以通过 Scanner 类来获取用户的键盘录入的数据。

使用步骤

由于目前相关语法还没学习，所以先把步骤记住。后面学习了相关语法再来讲解。

1、导包。在定义类的上面写上下面的语句。

import java.util.Scanner; 

2、创建对象

Scanner sc = new Scanner(System.in);

3、接收用户录入的数据并存储

int num = sc.nextInt(); // 表示将键盘录入的值作为int数返回。

演示：

//导包
import java.util.Scanner;
public class ScannerDemo {
	public static void main(String[] args) {
		//创建对象
		Scanner sc = new Scanner(System.in);
		//接收数据
		int x = sc.nextInt();
		//输出数据
		System.out.println(x);
	}
}

5变量

在程序运行过程中我们经常需要用一个东西来临时计算过程中的数据，这个东西就是变量。

在程序运行的过程中，变量的值可以再一定范围内变化。

定义格式

1.光定义，不赋值
格式：数据类型 变量名;

int num;//光定义一个int类型的变量num，但是还没有进行赋值

2.定义并赋值

​ 格式：数据类型 变量名 = 初始化值;

int num = 1024;

3.一次定义多个变量（不推荐）

int a = 10, b = 20; // 定义int类型的变量a和b，中间使用逗号隔开
int c,d; // 定义int类型的变量c和d，但是未赋值，中间使用逗号隔开

变量的使用

变量定义完后直接使用变量名即可代表该变量。

例如：

int num = 20;
num = 30;//把30赋值给变量num。赋值完成后，num的值为30
System.out.println(num);//使用输出语句输出num，实际输出的是num的值30

注意事项

1.变量有其作用范围，它的作用访问是定义他的那行代码所在的大括号内。

2.在同一个大括号中定义的变量名不能重复。

3.变量在使用之前，必须先初始化（赋值）。

4.定义long类型的变量时，需要在整数的后面加L（大小写均可，建议大写）。因为整数默认是int类型，加L相当于告诉计算机这个整数很特殊是long类型的。定义float类型的变量时，需要在小数的后面加F（大小写均可，建议大写）。因为浮点数的默认类型是double， 加F相当于告诉计算机这个小数很特殊是float类型的。

6标识符

标识符就是我们在写java代码的过程中给变量，方法和类等取的名字。

我们取名的时候需要遵循一定的命名规则(硬性规定)和命名规范(约定俗成)。

命名规则

• 由字母、数字、下划线“_”、美元符号“$”组成。
• 不能以数字开头
• 不能使用java中的关键字。

命名规范

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

​ 首字母小写，从第二个单词开始每个单词的首字母大写。 例如： nickname setAge getAge

• 大驼峰式命名：类名

​ 每个单词的首字母都大写。 例如：HelloWorld FileUploadController

7常用DOS命令

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

打开控制台（命令行窗口）

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

2、在要打开控制台的目录的地址栏输入cmd，然后按回车。直接可以再该目录下打开控制台。

3、在要打开控制台的目录下，按住shift不放在空白处鼠标右键点击:在此处打开PowerShell窗口

常用DOS命令及其作用

操作	说明
help	查看帮助文档
盘符名称:	盘符切换。E:回车，表示切换到E盘。
dir	查看当前路径下的内容。
cd 目录	进入单级目录。cd java
cd …	回退到上一级目录。
cls	清屏。

8方法

我们在编程过程中有的时候会遇到一些固定套路的代码，我们可以把这些代码封装成方法，这样我们后面去使用的时候就会更加的方便。并且代码也会更简洁，代码复用性更高。

方法的定义格式

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

​ 修饰符： 目前阶段使用public static 后期学完权限修饰符和static等修饰符后可以灵活使用

​ 参数： 执行方法需要的数据

​ 返回值: 方法执行完后得到的结果

​ 方法体：方法中的代码

​ 返回值类型：返回值执行完后结果的数据类型，如果没有结果就写成void

例如：

   public static void printInt(int num){
       System.out.println(num);
   }
   public static int getSum(int a,int b){
       return a+b;
   }

方法的调用格式

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

注意

​ 传参数的时候方法定义里有几个参数就传几个参数.方法定义的时候参数是什么类型就传什么类型.
​ 如果方法有返回值，一般是用变量来接收返回值，返回值是什么类型，就用什么类型的变量来接收。

例如：

public class Demo{
    public static void printInt(int num){
       System.out.println(num);
    }
    public static int getSum(int a,int b){
       return a+b;
    }
    public static void main(String[] args){
       printInt(10);
       printInt(20);
       int sum = getSum(1,2);
    } 
}

return的作用

​ 1.返回方法的返回值

​ 2. 结束方法(reutrn执行后整个方法执行结束)

方法重载

定义：在同一个类中,方法名相同,参数列表不同的方法才叫方法重载（与返回值无关）

参数列表不同：1. 参数类型不同 2.参数个数不同 3.参数顺序不同

如何判断参数列表是否相同？把参数类型全部拼接成一个字符串，如果字符串的内容不同就算参数列表不同。

public class Demo{
    public int test(int a,int b){}   // intint
    public void test(int a,int b){}//错  
    
    
    public void test(int a,int b,int c){}
    public void test(int x,int y){}//错   
    public void test(int a,double b){}
    public void test(double a,int b){}
    public void test(double a,double b){}
}

小思考

1.一个方法能不能有两个返回值?(PS:学会用代码去验证你的想法)

答案：不能直接返回，可以把结果放入数组中返回

2.没有返回值的方法中能不能写return?

答案： 可以，可以用来结束方法。但是return的后面不能跟数据;

3.看看下面代码的输出结果是什么?

	public static void main(String[] args) {
		int a = 10;
		int b = 20;
		System.out.println("a="+a);
		System.out.println("b="+b);
		change(a,b);
		System.out.println("方法调用后a="+a);
		System.out.println("方法调用后b="+b);
	}
	public static void change(int a,int b){
		int temp = a;//int temp = 10;
		a = b;//a = 20;
		b = temp;// b = 10;
	}

4.看看下面代码的输出结果是什么?

	public static void main(String[] args) {
		int[] arr = {1,2}
		System.out.println("arr[0]="+arr[0]);
		System.out.println("arr[1]="+arr[1]);
		change(arr);
		System.out.println("方法调用后arr[0]="+arr[0]);
		System.out.println("方法调用后arr[1]="+arr[1]);
	}
	public static void change(int[] arr){
		int temp = arr[0];
		arr[0] = arr[1];
		arr[1] = temp;
	}

问题：java中方法调用的时候，形参的改变会不会影响实参？

答：如果方法的参数是基本数据类型，形参的改变不会影响实参。如果方法的参数是引用数据类型，形参的改变会影响实参。

作业

看看下面代码的输出结果是什么?

    public static void main(String[] args) {
        int[] arr = {1,2};
        System.out.println("arr[0]="+arr[0]);
        System.out.println("arr[1]="+arr[1]);
        change(arr);
        System.out.println("方法调用后arr[0]="+arr[0]);
        System.out.println("方法调用后arr[1]="+arr[1]);
    }
    public static void change(int[] arr){
        arr = new int[2];
        arr[0] = 2;
        arr[1] = 1;
    }

9计算机存储单位

在计算机内部，信息都是釆用二进制的形式进行存储、运算、处理和传输的。信息存储单位有位、字节等几种。各种存储设备存储容量单位有KB、MB、GB和TB等几种。

位（bit）： 是计算机中数据的最小单位。

字节（Byte，B）：计算机中数据的基本单位，每8位组成一个字节。

各个单位换算关系

1B（字节） = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

10流程控制语句-if

在程序中我们需用去判断不同的情况做不同的处理，这个时候就需要使用到流程控制语句来处理。我们先来学习最常用的流程控制语句if。

格式

if语句其实有三种部分组成的

三个部分:
①if部分

​ if(判断表达式){
​ 语句体;
​ }
​ ② else if部分

​ else if(判断表达式){
​ 语句体;
​ }
​ ③else部分

​ else{
​ 语句体;
​ }

一个完整的if语句，首先在最前面有且仅有一个if部分,后面会有0个到多个else if语句,最后会有0个或1个else

例如：

if(判断表达式1){
    语句体1;
}

if(判断表达式1){
    语句体1;
}else if(判断表达式2){
    语句体2;
}

if(判断表达式1){
    语句体1;
}else if(判断表达式2){
    语句体2;
}else if(判断表达式3){
    语句体3;
}

if(判断表达式1){
    语句体1;
}else if(判断表达式2){
    语句体2;
}else if(判断表达式3){
    语句体3;
}else if(判断表达式4){
    语句体4;
}else{
    语句体n+1;
}

if(判断表达式1){
    语句体1;
}else{
    语句体n+1;
}

执行流程

​ 从上到下依次执行判断表达式
​ 结果为true:则执行后面紧跟着的语句体.语句体执行完了整个if语句就结束了.
​ 结果为false:则继续判断下面一个判断表达式
​ 如果所有判断表达式的结果都为false,在有else语句的情况下就执行else里面的语句体,没有的话if语句结束.

例如：

    public static void main(String[] args) {
        //输入年龄  判断是否能够进入网吧
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你的年龄");
        int age = sc.nextInt();
        //判断age>=18
        if(age>=18){
            System.out.println("可以进入网吧");
        }else{
            System.out.println("未成年不能进入网吧");
        }

    }

注意

​ ①一旦执行了一个大括号中的语句体,整个if语句就结束了.不可能出现执行两个语句体的情况.
​ ②如果大括号中的语句体只有一行代码的时候可以把大括号省略.但是建议永远不要省略

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RhYQhaI7-1681564539232)(img\image-20200815191653289.png)]

​ 世界上最遥远的距离就是你在if里,我在else里,似乎一直相伴,却永远无法结伴而行.

练习

1.判断下面代码的输出结果

int a=10;
int b=20;
if(a>5){
	System.out.print(1);
}else if(b>10){
	System.out.print(2);
}else{
	System.out.print(3);
}
System.out.print(4);

2.判断下面代码的输出结果 1 5 9

int a=10;
int b=20;
if(a>1){
	System.out.print(1);
	if(b>22){
		System.out.print(4);
	}else if(a>3){
		System.out.print(5);
	}

	if(a>20){
		System.out.print(8);
	}else{
		System.out.print(9);
	}
}else if(a>9){
	System.out.print(2);
	if(b>10){
		System.out.print(6);
	}else if(a>3){
		System.out.print(7);
	}
}else if(b>2){
	System.out.print(3);
}

3.按照要求编写代码

让用户键盘录入语文，英语，数学的考试成绩。如果总分小于180分要求输出：由于你的优秀，我想和你家长聊聊。

4.按照要求编写代码

让用户键盘录入语文，英语，数学的考试成绩。如果总分小于180分要求输出：由于你的优秀，我想和你家长聊聊。否则就输出：同九义，何汝秀

5.按照要求编写代码

让用户键盘录入语文，英语，数学的考试成绩。

​ 满足不同的条件输出不同的内容（要求只能输出一种）

条件	输出内容
总分<180	叫家长
总分>=180并且语数外分数都大于98分	恭喜升任五道杠大队长
总分>=180但是做不了五道杠的情况下如果语数外分数都大于95分	恭喜升任班长
总分>=180即做不了五道杠也做不了班长的情况下	同九义，何汝秀

6.下面代码的执行结果是什么?

int a=10;
int b;
if(a%2==0){
    b=0;
}else if(a%2==1){
    b=1;
}
System.out.println(b);

答案： 会在编译的时候报错.因为在编译的时候编译器看到了if…else if语句.它认为有可能两个判断都不成立.这样的话b就可能出现没有赋值直接使用的情况.

11流程控制语句-switch

使用switch也可以根据判断不同的情况做不同的处理。

格式

		switch (表达式) {
			case 值1:
				语句体1;
				break;
			case 值2:
				语句体2;
				break;
			case 值3:
				语句体3;
				break;
			...
			default:
				语句体n+1;
				break; // 最后一个break语句可以省略，但是推荐不要省略
		}

switch后面小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举

例如：

    public static void main(String[] args) {
        int num = 2;
        switch (num){
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                //break;
            case 3:
                System.out.println(3);
                //break;
            default:
                System.out.println("default");
                break;
        }
        
    }

执行流程

​ 从上到下依次看表达式的结果和哪个case后面的值相同,相同就执行那个case后面的语句体,碰到break就结束switch.
​ 如果没有符合要求的case则执行default后面的语句体.

注意事项

​ ①switch可以没有default,但是一般都会加上
​ ②case语句后面可以不加break.但是如果不加break就可能会出现case穿透问题.匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整个switch结束为止;

小思考

switch和if都可以做多种情况的判断,那他们之间有什么区别呢?你觉得谁更灵活?

tips:可以从他们小括号里能写的表达式的类型方面去考虑
if的小括号中是布尔表达式，switch是byte,short…

答案：

if的表达式的布尔表达式，可以进行更复杂条件的判断(例如：值在某个范围内，多个条件同时符合等)而switch的表达式的数据类型只能适合做有限个数的等值判断。所以如果是有限个数的等值判断的话switch有的时候会更方便。其他情况下if会更适合。

练习

1.键盘输入0-6之间的整数，分别代表每周的星期日、星期一、

…、星期六在控制台进行输出。如果用户输入了0-6之外的数提示：请输入0-6之间的整数。

2.一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，请用程序实现判断该月份属于哪个季节，并输出。

春：3、4、5
夏：6、7、8
秋：9、10、11
冬：1、2、12

12面向对象-抽象类

1. 为什么要抽象

​ 当一个类中有一个方法,这个方法在不同的子类中有不同的实现的时候,在父类中我们没有办法去写具体的方法体,这个时候就可以使用抽象.(即不写方法体)

2. 抽象类和抽象方法的格式

2.1 抽象方法

​ 在成员方法的返回值类型前加abstract修饰，然后去掉方法的大括号,加上一个分号。

例如

public abstract void eat();

2.2 抽象类

​ 在class关键字的前面加上 abstract 修饰。

例如

public abstract class Animal{
    
}

3. 抽象类的特点

• 抽象类可以有抽象方法，还有就是不能直接创建对象，其他所有都和普通类一样
• 抽象类的子类，要么重写抽象父类中所有的抽象方法，要么子类本身也是一个抽象类

13面向对象-代码块

1. 局部代码块

1.1 格式

​ 在方法中直接写一对大括号即可

public class Demo{
    
    public void test(){
        int a = 10;
        //下面是一个局部代码块
        {
            int b = 20;
        }
    }
}

1.2 应用场景

​ 如果需要控制局部变量的生命周期，想让其使用完后尽快销毁，可以把局部变量定义在局部代码块

2. 构造代码块

2.1 格式

​ 在类中方法外部直接写一对大括号即可

public class Student{
    
    int age;
     //下面是一个构造代码块
    {
       age = 0;
    }

}

2.2 调用时机

​ 构造代码块会在调用构造方法的时候执行，并且会在构造方法中的代码执行之前执行。

2.3 应用场景

​ 用来抽取构造方法中的重复代码，提高代码的复用性。

3. 静态代码块

3.1 格式

​ 在类中方法外部直接写一对大括号即可，在括号前用static修饰

public class Student{
    
    static int num;
     //下面是一个构造代码块
    static {
       num = 0;
    }

}

3.2 调用时机

​ 在类被加载的时候会执行，同一个类在程序运行过程中只会被加载一次，所以只会执行一次

3.3 应用场景

​ 用来给类当中的静态成员进行初始化。

14面向对象-多态

1. 多态的概念

​ 同一个数据类型的不同对象对同一种行为会有多种不同的实现。

2. 多态的前提

​ ① 子类重写了父类的方法

​ ② 父类引用指向子类对象（创建的是一个子类的对象，并把该对象赋值给一个变量，这个变量的类型是其父类类型）

​ 例如：

Animal a = new Dog();
Animal b = new Cat();

3. 父类引用指向子类对象后成员访问的特点

​ 除了成员方法编译看左边，运行看右边。其他所有成员都是编译看左边，运行看左边。

​ 解读：编译期间会去看左边(父类),看父类有没有这个成员方法。如果没有则直接报错,如果有则编译通过,不报错。运行期间,实际执行代码,看的是右边(子类),看子类中有没有重写该方法,如果有则执行子类中的该方法,如果没有
则运行父类中的该方法。

4. 多态的应用场景

​ 多态最大的应用场景其实就用在方法的参数上。在适当的时候把方法的参数类型定义成父类类型。调用方法的时候就可以传入任意的子类对象。提高了代码的复用性和可扩展性。

5. 多态的优缺点

优点：提高了代码的复用性和可扩展性

缺点：不能直接使用子类的成员。

6.向上转型，向下转型

6.1 向上转型

​ 向上转型就是子类转父类。因为是绝对安全的所以会自动进行转换。

例如：

	Animal a = new Dog();

6.2 向下转型

​ 向上转型就是父类转子类。因为不是绝对安全的所以必须使用强转的方式来进行转换。

例如：

	Animal a = new Dog();
	Dog d = (Dog)a;

注意：必须是这个子类的对象才可以转换成该子类,否则会出异常

6.3 instanceof进行类型判断

​ 在向下转型的时候为了保证安全我们可以使用instanceof进行类型判断。判断一个对象是否某个类的对象。如果是的话我们再把它转换成该类型，这样会更加安全。

6.3.1 使用格式

​ 对象 instanceof 类名/接口名

示例：

	//判断对象是否是某个类的对象，如果是结果为true，如果不是结果为false
	Animal a = new Dog();
	if(a instanceof Dog){
        //说明a是Dog这个类的对象，我们可以把他强转成Dog类型
        Dog d = (Dog)a;
    }

7. 思考题

思考下面代码的输出结果

class A {  
	 public String show(D obj){  
			return ("A and D");  
	 }   
	 public String show(A obj){  
			return ("A and A");  
	 }   
}   
class B extends A{  

	 public String show(B obj){  
			return ("B and B");  
	 }  
	 public String show(A obj){  
			return ("B and A");  
	 }   
}  
class C extends B{}   
class D extends B{}

class  DynamicTest
{	
	public static void main(String[] args){
		A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();   
        D d = new D();   
        System.out.println(a1.show(b));  
        System.out.println(a1.show(c));  
        System.out.println(a1.show(d));  

        System.out.println(a2.show(b));   
        System.out.println(a2.show(c));           
        System.out.println(a2.show(d));  

        System.out.println(b.show(b));   
        System.out.println(b.show(c));  
        System.out.println(b.show(d)); 	 
	
	}
}

15面向对象-封装

1.封装的概念

​ 封装其实就相当于把不需要用户了解细节（隐私或者的特别复杂的细节)包装(隐藏)起来，只对外提供公共访问方式 。

2. 成员变量私有化（封装的一种体现形式）

​ 我们可以使用private来修饰成员变量，提供对应的set/get方法提供刚刚的访问方式。

2.1 private

​ private是一个修饰符,它可以用来修饰类中的成员变量或者成员方法,被它修饰的成员变量只能在本类中访问,不能在其他类中直接访问

例如：

public class Phone{
    private String brand;//在成员变量定义的前面加上private修饰
}

2.2 set/get方法

​ setXxx方法用来对成员变量赋值，所以方法参数一般是和这个成员变量是同一个数据类型，没有返回值。

​ getXxx方法用来获取成员变量的值，所以方法一般是没有参数，有返回值，返回值类型就是这个成员变量的数据类型。

​ 注意：上面的Xxx代表成员变量名，注意遵循小驼峰命名规范

例如：

public class Phone{
    private String brand;
    public void setBrand(String brand){
        this.brand = brand;
    }
    public String getBrand(){
        return brand;
    }
    public Phone(String brand){
        this.brand = brand;
    }
}

3. this

​ this可以用来在局部变量和成员变量重名的时候区分他们，加了this的就是成员变量。

​ 注意：我们只能在一个类的成员方法或者构造方法中去使用this。

3.1 小思考

​ this究竟代表什么？this代表当前对象

4.思考

​ 我们之前用构造方法可以给成员变量赋值，现在学习了set方法也可以给成员变量赋值。那么它们使用起来有区别吗？

​

16面向对象-继承

1. 继承的概念

​ 继承可以理解为就是让两个类（事物）产生从属关系，有了从属关系子类就肯定会具有父类的特征（父类中的非私有成员），这样我们用类去描述一些事物的时候就可以更方便

1.1 相关名词

​ 超类，父类都是同一个概念就是叫法不同

​ 派生类，子类都是同一个概念就是叫法不同

2. 继承的格式

​ 在子类名后面加extends 父类名

例如

public class Dog extends Animal {
  //Dog就成为了Animal的一个子类
}

3. 继承的注意事项

• java中类只能单继承,一个类只能有一个父类,但是可以多层继承
• 要有实际的从属关系才可以继承，不能不合逻辑的任意继承。

4. 继承的优缺点

4.1 优点

​ 提高了代码的复用性

4.2 缺点

​ 增加了类和类之间的耦合性。违背了高内聚，低耦合原则

5. 继承后成员相关语法

​

5.1 成员变量

1. 父类非私有的成员变量才会继承给子类。所以当我们看到使用子类对象的某个成员变量时，有可能这个成员变量是定义在子类中。也有可能是定义在其父类中。

2. 父类中如果已经有了某个成员变量，我们不应该再在子类中定义同名的成员变量。否则可能会导致非常难排查的Bug。

5.2 构造方法

1. 构造方法不会继承给子类

2. 子类的构造中必须调用父类的构造并且要求在第一行。

3. 子类的构造默认都会在第一行调用父类的无参构造，所以当父类没有无参构造的时候子类构造中会报错。解决方案是给父类加上无参构造或者在子类构造中显示的调用父类的有参构造。

理解

问：继承的时候构造方法为什么不会被继承？

答： 假设会被继承,这个方法名和子类的类名就肯定不相同,所以不能算是构造方法.所以假设不成立

问：子类的构造方法会默认调用父类的无参构造super().为什么?

答：因为父类中可能有成员变量,并且这个成员变量要继承给子类使用,但是所有的变量在使用之前必须先赋值.而父类的成员变量只能用父类的构造进行默认的初始化。

问：在子类的构造方法中,能不能把父类的构造放到第二行?

答：不能,因为要保证成员变量先初始化了.如果放到第二行,有可能在第一行还没初始化的时候就使用的父类的成员变量

5.3 成员方法

​ 父类非私有的成员方法会继承给子类。所以当我们看到使用子类对象的某个成员成员方法时，有可能这个成员方法是定义在子类中。也有可能是定义在其父类中。

​

6. 方法重写

6.1 方法重写的概念

​ 当子类拥有父类继承下来的某个功能（成员方法）,但是在子类中对这个方法的具体实现和父类不同。这个时候我们在子类中定义了一个和父类方法相同的方法(包括返回值类型,方法名,参数列表) ，这就叫做方法重写。

6.2 注意事项

• ​ 我们在重写方法的时候方法的权限修饰符其实可以和父类不同**（一般都相同）。但是子类中方法的权限不能比父类低。（权限修饰符 : private < 默认(什么都不写) < protected < public）**

• ​ 我们在重写方法的时候方法的返回值类型其实可以不同**（一般都相同）**。但是要求子类中方法的返回值类型必须是父类方法返回值类型的子类。

• ​ 我们可以用 @Override 注解来校验是不是方法重写。

• ​ 私有的方法不能被重写，因为私有的不会被继承

6.3 小思考

面试题：说说overload和override的区别。

答：
方法重载：在同一个类中，方法名相同，参数列表不同，和返回值无关
方法重写：在子父类中，子类有一个和父类方法名相同，参数列表相同，返回值类型也相同的方法。这个就叫方法的重写

7. this和super

​ this就代表本类的，super就代表父类的

使用：

• 访问成员变量
• ​ this.成员变量名 本类的成员变量
• ​ super.成员变量名 父类的成员变量
• 访问成员方法
• ​ this.成员方法名(参数) 调用本类的成员方法
• ​ super.成员方法名(参数) 调用父类的成员方法
• 调用构造方法
• ​ this(参数) 调用本类的构造方法
• ​ super(参数) 调用父类的构造方法

17面向对象-接口

1. 接口的概念

​ 接口就是规范\规则，我们可以使用接口来定义一些规则（比如要求某个方法的方法名必须叫什么，方法的参数列表必须是什么，方法的返回值类型必须是什么）

​ 现实生活中的规范

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UOuO4sBb-1681564622911)(img\image-20201018110217344.png)]

2. 接口的格式

2.1 定义接口

​ 使用interface来定义接口

public interface 接口名{
    //定义抽象方法
    void method();
}

2.2 实现接口

​ 在要实现接口的类名后面加上implements 接口名。如果要实现多个接口，多个接口名用逗号分开。我们在理解的时候可以把接口理解成是一个特殊的父类。

 public class 类名 implements 接口名{}

3. 接口中的成员

3.1 常用成员

​ 在jdk7版本中接口中只能有常量和抽象方法。

​ 我们接口中定义不了成员变量。因为定义的成员变量默认都会修饰为：public static final

​ 我们在接口中定义的方法默认修饰符为public abstract

例子

public interface InterfaceA {
    //常量
    int NUM =10;//等价于public static final int NUM =10;
    //抽象方法
    void method();//等价于  public abstract void method();
}

3.2 新增成员

​ 在新版本的jdk中接口中允许出现更多的成员。

3.2.1 默认方法

​ 在jdk8中允许我们在接口中定义默认方法。默认方法允许有方法体。

​ 默认方法可以选择不进行重写。

3.2.1.1 格式

​ 使用defaut关键字进行修饰。

public interface InterfaceA {
	//默认方法
    default void method(){

    }
}

3.2.1.2 注意事项

​ 如果两个接口中有相同的默认方法。一个类同时实现了这两个接口，必须要重写该方法。

3.2.1.3 应用场景

​ 如果在接口升级的时候某些方法并不想让所有的实现类进行重写，可以使用默认方法来定义。

3.2.2 静态方法

​ 在jdk8中允许我们在接口中定义静态方法。静态方法允许有方法体。

​ 静态方法不能被重写。

3.2.2.1 格式

​ 使用static关键字进行修饰。

public interface InterfaceA {
	//静态方法
    static void staticMethod(){

    }
}

public class Demo {
    public static void main(String[] args) {
        //使用接口名.方法名(参数)  来调用
        InterfaceA.staticMethod();
    }
}

3.2.2.2 应用场景

​ 如果在接口升级的时候需要给接口增加一些工具方法。不想让实现类去重写该方法，可以使用静态方法来定义。

3.2.3 私有方法

​ 在jdk9中允许我们在接口中定义私有方法。私有方法允许有方法体。

​ 私有方法不可以被重写。

3.2.3.1 格式

​ 使用private进行修饰。

public interface InterfaceA {
    private static void privateStaticMethod(){

    }
    private  void privateMethod(){

    }
}

3.2.3.2 应用场景

​ 对默认方法或者是静态方法中重复的代码进行抽取，提高代码复用度。

4. 继承实现关系

​ 在java中一个类可以实现多个接口

例如

 public class Person implements InterfaceA,InterfaceB{}

​ 在java中接口和接口之间可以有继承关系。继承之后会把父接口的成员继承下来。

public interface InterfaceC  extends InterfaceA{
//    void method1();
}

5. 抽象类和接口的使用区别

​ 接口中的基本都是抽象的，而在抽象类中可以有一部分是非抽象方法。而非抽象类中是不可以有抽象方法的。

​ 我们就发现接口是最抽象的，其次是抽象类，最后是非抽象类。
​ 所以我们最顶层设计成接口，然后实现类设计成抽象类（实现部分抽象方法），抽象类的子类可以设计成非抽象类（对剩下的所有抽象方法进行实现）。

18面向对象-内部类

1. 局部内部类

1.1 格式

1.1.1 定义格式

​ 把类定义在方法中即可

public class Outer{
    
    public void test(){
        class Inner{//定义了一个局部内部类
			public void print(){
				System.out.println("局部内部类");	
            }
		}
    }
}

1.1.2 对象创建格式

​ 直接在定义局部内部类的方法中安装之前创建对象的格式进行创建即可。如果在该方法外就不能使用该局部内部类了。

public class Outer{
    
    public void test(){
        class Inner{//定义了一个局部内部类
			public void print(){
				System.out.println("局部内部类");
			}
		}
        Inner inner = new Inner();
        inner.print();
    }
}

1.2 应用场景

​ 如果需要定义一个在方法中临时使用的类时可以使用局部内部类。不过该内部类基本不会使用到。

1.3 注意事项

​ 内部类可以使用外部的局部变量。但是要求这些局部变量必须是事实常量。

2. 成员内部类

2.1 格式

2.1.1 定义格式

​ 把类定义在类中即可

public class Outer{
    
    class Inner{//定义了一个成员内部类
        public void print(){
            System.out.println("局部内部类");
        }
    }
}

2.1.2 对象创建格式

​ 在定义内部类的类中创建对象即可。

public class Outer{
    private Inner inner = new Inner();
    class Inner{//定义了一个成员内部类
        public void print(){
            System.out.println("成员内部类");
        }
    }
}

2.2 特点

​ ①在成员内部类中可以直接使用外部类的成员，即使这个成员是私有的。

​ ②如果外部类的成员和内部类的成员重名了，可以使用外部类名.this.成员名来表示外部类的成员。

​ ③成员内部类中不能定义静态的成员。（非静态中不用使用静态)

public class Outer{
    private Inner inner = new Inner();
    private int num = 10;
    
    private void test(){
        System.out.println("外部类中的test方法被调用");
    }
    class Inner{//定义了一个成员内部类
        public void print(){
            System.out.println("成员内部类");
            System.out.println(num);//等价于Outer.this.num
            test();//等价于Outer.this.test();
        }
    }
}

2.3 应用场景

​ 一个类不会单独使用，需要和另外类（外部类）一起使用才有意义。并且会用到外部类中的私有成员的时候可以把该类定义为一个内部类。例如ArrayList中的Itr

3. 静态内部类

3.1 格式

3.1.1 定义格式

​ 把类定义在类中方法外，然后使用static关键字修饰即可。

public class Outer{

    static class Inner{//定义了一个静态内部类
        public static void print(){
            System.out.println("静态内部类");
        }
    }
}

3.2 特点

​ 在静态内部类中可以直接使用外部类静态成员，即使是私有的。

3.2 应用场景

​ 一个类不会单独使用，需要和另外类（外部类）一起使用才有意义。需要在内部类中定义静态成员的时候，可以把成员内部类用static修饰变成静态内部类。例如Integer中的IntegerCache

4. 匿名内部类

​ 匿名内部类本质是一个对象。它是某个类(接口)的子类(实现类)对象。

4.1 格式

	new 接口名/类名(){
      	//重写要重写的方法  
    };

interface Runner{
    void run();
}
public class Demo{
    public static void main(String[] args){
        Runner r = new Runner(){
            public void run(){
                System.out.println("匿名内部类重写了run方法");
            }
        };
        r.run();
    }
    
    
}

4.2 应用场景

​ 如果需要创建一个类或者接口的子类对象。但是这个子类只会使用一次，没必要创建单独创建一个类。就可以使用匿名内部类的形式。

入门阶段

DOS命令

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

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

2、常用命令及其作用

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

JVM、JRE、JDK

JVM（Java Virtual Machine），Java虚拟机，java程序需要在jvm上运行

JRE（Java Runtime Environment），Java运行环境，包含了JVM和Java的核心类库（可供我们直接使用的代码）

JDK（Java Development Kit）称为Java开发工具，包含了JRE和开发工具

作为一个Java开发者我们需要安装什么呢？JDK

---

##JDK安装和配置

JDK安装

傻瓜式安装，下一步即可。但默认的安装路径是在C:\Program Files下，建议修改到其他盘符，例如：E:\Develop。

注意：安装路径不要包含中文或者空格等特殊字符（使用纯英文目录）。

验证是否可用

进入jdk安装目录的bin目录下，在该目录下打开控制台，输入java -version目录进行测试

如果出现类似如图效果即算安装成功

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-JX7iPUPd-1681564724885)(img\image-20200810222448576.png)]

####环境变量配置

为了让我们再任意目录下都可以使用jdk提供的开发工具。我们需要把这些工具所在的目录配置到环境变量中。

步骤TODO

---

第一个程序HelloWorld

1、新建文本文档文件，修改名称为HelloWorld.java。

2、用记事本打开HelloWorld.java文件，输写程序内容。

public class HelloWorld {
	public static void main(String[] args) {
		System.out.println("HelloWorld");
	}
}

保存文件，java文件所在目录打开命令行窗口，编译java文件生成class文件（javac 文件名包含扩展名），运行class文件（java 类名）。

范例如下：

javac HelloWorld.java

java HelloWorld

效果图：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ES5dEImK-1681564724886)(img\image-20200811112129302.png)]

常见问题

1、非法字符问题。Java中的符号都是英文格式的。

2、大小写问题。Java语言对大小写敏感（区分大小写）。

3、在系统中显示文件的扩展名，避免出现HelloWorld.java.txt文件。

4、main写错成mian

IDEA安装使用

步骤TODO

19数据类型

Java中的数据必须明确数据类型。在Java中的数据类型包括基本数据类型和引用数据类型两种。目前主要讲基本数据类型，除了基本数据类型之外的都是引用数据类型

Java中的基本数据类型：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-evN2iRTe-1681564730746)(img\image-20200814195416786.png)]

注意：

​ 在java中，我们写的整数值默认就是int类型，我们写的小数值默认就是double类型。

数据类型转换

自动类型转换

数据绝对安全的类型转换是可以自动转换的直接书写即可。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-O0C7f6m8-1681564736094)(img\image-20200815113921531.png)]

例如：

double num = 1024;//  int -> double   安全
long l = 1024;//int -> long  安全
double num2 = 3.14F;//float -> double  

强制类型转换

转换后可能导致出现问题（数据溢出，丢失数据精度）的类型转换叫做强制类型转换。因为可能出现问题必须给计算机一个特殊标识，格式如下：

目标数据类型 变量名 = (目标数据类型)值或者变量;

例如：

int a = (int)3.14;//double -> int 

练习

1.观察下面代码会不会报错，并说明报错原因及解决方案

	int i = 100L;//long -> int


	float f = 2.0;//double->float

	
	int a = 3.14;

20数组

我们可以使用数组来保存同一个数据类型的多个数据

数组的特点

​ ①数组的长度一旦确定就不能改变

​ ②一个数组中元素的数据类型都是一样的

数组的初始化

动态初始化

格式

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

例如：

	int[] arr = new int[10];//动态初始化了一个长度为10的数组，数组元素为int类型

静态初始化

格式

​ 标准格式：

​ 数据类型[] 数组名 = new 数据类型[] {元素值1,元素值2,元素值3,…};

例如：

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

​ 省略格式（推荐使用）：

​ 数据类型[] 数组名 = {元素值1,元素值2,元素值3,…};

例如：

	int[] arr = {1,2,3,4,5};

总结

​ 静态初始化和动态初始化都可以实现对数组的初始化，那么我们在需要创建数组的时候应该如何选择呢？

​ 如果数组元素都确定好了，并且个数有限的情况下我们可以使用静态初始化，因为更方便。如果只能确定数组的长度，数组的元素值需要后面再赋值的话可以使用动态初始化。

数组元素的表示

格式

​ 数组名[索引值]

例如：

	  int[] arr = {1,2,3,4};
	  //输出数组arr的第一个元素
	  System.out.println(arr[0]);
	  //把数组arr的第3个元素值修改为5
	  arr[2] = 5;

注意

​ 索引值就是一个int数字，代表数组当中元素的编号。

​ 索引值从0开始，一直到“数组的长度-1”为止。例如长度为5的数组他的索引范围为0到4

数组的内存结构

观察下面代码的输出结果

int[] arr = new int[5];
arr[0] = 1;
arr[1] = 2;
int[] arr2 = arr;
arr2[2] = 3;
arr2[3] = 4;
System.out.println(arr2[0]);
System.out.println(arr[3]);

如果想要弄明白上面代码的输出结果就需要知道一个数组在内存中是如何存储的。

实际上，数组的实体保存在堆中，数组名实际保存的是数组实体的地址值。

数组长度

在java中我们可以非常方便的获取到数组的长度，格式如下：

​ 数组名.length

例如：

	  int[] arr = {1,2,3,4};
	  //输出数组长度
	  System.out.println(arr.length);

数组的遍历

我们在操作数组的时候很多时候需要对数组的每个元素挨个操作一遍，这种情况下我们就可以对数组进行遍历操作。

int[] arr={1,2,3,4,5,7};
//遍历输出数组元素
for(int i=0;i<arr.length;i++){
	System.out.println(arr[i]);
}

常见问题

1.观察下面程序的执行结果 ArrayIndexOutOfBoundsException 数组索引越界

int[] arr = new int[3];
arr[1] = 1;
arr[2] = 2;
arr[3] = 3;
System.out.println(arr[2]);

21数组-练习题

1.定义一个长度为100的int数组,要求里面的元素分别为1,3,5,7,9…最后还要把数组里面的每个元素都打印出来

2.定义一个长度为10的int数组，要求用户使用键盘录入分别给数组的每个元素赋值。最后计算出该数组所有元素的总和，最大值，最小值并打印到控制台中。

3.定义2个长度为5的字符串数组arrA和arrB，arrA包含元素{“1”,“2”,“3”,“4”,“5”}，arrA中的所有元素按逆序存储在数组arrB中，

在控制台打印输出arrB数组中所有元素

4.分析以下需求，并用代码实现：

(1).定义一个int类型的数组，内容为{171,72,19,16,118,51,210,7,18}

(2).求出该数组中特定元素的和，特定元素是指个位和十位不包含7的偶数。

5.分析以下需求，并用代码实现

定义一个数组，数组的元素为：{3，4，11，55，32，10，8，5}，要求使用代码对该数组进行从大到小的排序，排序后的结果为{55，32，11，10，8，5，4，3}

6.分析以下需求，并用代码实现

有一对兔子，从出生后第三个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问第二十个月的兔子对数为多少？

22修饰符

1. 包和权限修饰符

1.1 包

​ 包其实就是文件夹，用来管理我们的类的。一个类的全类名其实是包名加类名（在java中要求全类名是不能重复的）。

1.1.1 包的定义格式

​ 在类的最上面加上 package 包名;

例如

package com.sangeng;

1.1.2 导包

​ 当我们在一个类中使用另外一个类的时候，如果这个类在另外一个包下。我们必须要写全类名或者导包（如果是在java.lang包下的类我们也不需要）。

格式：import 全类名;
例如

import java.util.Scanner;

1.2 权限修饰符

​ 我们使用权限修饰符来控制被修饰的成员的使用权限。Java中有四种权限修饰符：public，protected，default（default并不是关键字，而是代表不写权限修饰符），private

1.2.1 权限

​ 被不同的权限修饰符修饰后，被修饰的成员可以在不同范围内被使用。

	本类中	同一个包下	子类	不同包非子类
public	√	√	√	√
protected	√	√	√
默认	√	√
private	√

1.2.2 使用规律总结

​ 我们在工作中一般不使用默认的权限。如果一个成员我们只想在本类中使用我们就使用private修饰。如果我们想只被本类和子类使用可以使用protected。如果可以被人任意使用，我们使用public。

2. static

​ static是一个修饰符，被其修饰的成员就属于类了。会被类的所有对象所共享。

2.1 静态成员的调用格式

​ 无论是成员变量，还是成员方法。用static修饰后我们即可以用对象名来调用也可以用类名来调用。一般都使用类名称进行调用。

​ 静态变量：类名.静态变量名
​ 静态方法：类名.静态方法名(参数)

例如

class Student{
	public static int num;
    public static void test(){}
}
class Demo{
    public static void main(String[] args){
        Student.num = 10;
        Student.test();
    }
}

2.2 注意事项

​ 1.静态方法中不能直接使用非静态的成员

​ 2.静态方法中不能使用this

2.3 理解

​ 因为被static修饰的东西就属于类了,所以可以使用类名来调用
​ 因为被static修饰的东西就属于类了,类的加载优先于对象,所以在静态方法中,不能使用非静态的成员(PS:非静态的成员是属于对象),类出现的时候对象还不存在,所以不能使用还不存在的东西
​ 因为被static修饰的东西就属于类了,而this代表的某个对象,类加载的时候对象还没创建,所以在静态方法中不能使用this,因为对象都没有出现呢

2.4 使用场景

​ ①如果需要共享数据,可以使用static
​ ②如果想要方便调用某些成员,可以使用static修饰(PS:因为就可以直接用类名来调用,不需要创建对象)

3. final

​ final可以修饰类，成员方法，局部变量，成员变量。

​ 修饰后的作用如下：
​ ①可以修饰类,被final修饰的类不能被继承.
​ ②可以修饰成员方法,被final修饰的成员方法不能被重写
​ ③可以修饰局部变量,被final修饰的局部变量就变成了常量，赋值之后就不能被修改
​ ④可以修饰成员变量,被final修饰的成员变量就变成了常量,一旦赋值之后就不能被修改.并且必须初始化。有两种初始化方式，一种是直接赋值，另外一种是要在类的所有的构造方法中对其进行赋值.

23循环控制语句

我们在循环的过程中有的时候可能需要跳过某次或某几次循环、甚至直接结束整个循环。这个时候我们就可以使用循环控制语句。

循环控制语句主要有两个：break,continue

break

在循环过程中,碰到break 整个循环 就直接结束了

例如：

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);//0 1 2 3 4 5
            if(i==5){
                break;
            }
        }

    }

注意：break只能出现在循环中或者switch中

continue

如果在循环过程中碰到了continue,则 跳过本次循环 , 继续下次循环

   public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            
            if(i==5){
                continue;
            }
            System.out.println(i);//0 1 2 3 4 6 7 ... 9
        }
    }

注意：continue只能出现在循环中

小练习

下面代码的输出结果

		public static void main(String[] args) {
			for(int x=1; x<=10; x++) {
				if(x%2==1) {
					//这里如果写的是break，continue的话分别会输出几次三更草堂
                    
				}
				System.out.println("三更草堂");
			}
		}

常见小问题

下面代码的执行结果

int a = 10;
if(a%2==0){
    if(a==0){
        break;
    }
    System.out.println("a是偶数");
}else{
    System.out.println("a是奇数");
}

答案：直接报错，break只能出现在循环或switch语句中

下面代码会输出哪些数字
代码:

	for(int i=1;i<10;i++){
		if(i%2==0){
			continue;
		}else{
			break;
		}
		System.out.println(i);
	}

答案：因为最后的输出语句永远执行不到,这个时候编译的时候就会报错

24循环语句

当我们需要多次执行完全重复的操作或者是多次执行有规律的操作时，我们就可以用循环语句。

在java中有三种循环语句，分别是for循环，while循环，do…while循环。

for循环

格式

		for(初始化语句;布尔表达式(条件判断);步进语句){
			循环体;
		}

例如：

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

执行流程

​ ①先执行初始化语句,

​ ②然后看布尔表达式的结果,

​ 如果为false 循环结束,

​ 如果为true 执行循环体.

​ ③循环体执行完后执行步进语句.然后继续执行②判断布尔表达式的结果(PS:注意,不是初始化语句)

​ 然后以此类推.

注意

①初始化语句、布尔表达式、步进语句之间是用分号分隔，而不是逗号。 但是在初始化语句和步进语句部分，我们可使 用一系列由逗号分隔的语句。而且那些语句均会独立执行 。例如：

		for(int i = 1,j = 10;i<j;i++,j--){
			循环体;
		}

②无论初始化语句，布尔表达式，还是步进语句，都可以空着不写，但是分号不能少 。例如：

		for(;;){
			循环体;
		}

③如果在初始化语句中定义了变量，那么该变量只能在循环中使用，循环结束了就出来变量的作用范围

小思考

​ ①初始化语句会执行几次?

​ 答案： 只有在最开始的时候执行了一次
​ ②什么情况下循环体一次都执行不了?

​ 答案： 如果第一次进行条件判断的时候结果为false则循环体一次都执行不了

练习

1.输出1~100所有的数

2.输出100~1的所有的数

3.要求求出1~100的和

4.求1~100的偶数和

5.求1~100中既能被3整除又能被5整除的数有多少个

While循环

格式

	while(布尔表达式){
		循环体;
	}

例如：

    public static void main(String[] args) {
        int i = 0;
        while (i<=10){
            System.out.println(i);//0  1  2   ... 10   
            i++;
        }
    }

执行流程

​ ①看布尔表达式的结果

​ 如果为false循环结束

​ 如果为true,则执行循环体.

​ ②循环体执行完后继续执行①以此类推

do…while循环

格式

		do{
			循环体;
		}while(布尔表达式);

例如：

    public static void main(String[] args) {
        int i = 0;
        do{
            System.out.println(i);//0  1  2  3 4 ...  10
            i++;
        }while (i<=10);
    }

注意：while小括号后面必须有个分号。

执行流程

​ ①执行循环体

​ ②然后看布尔表达式的结果

​ 如果为true则继续执行①循环体

​ 如果判断表达式的结果为false则循环结束

​ 以此类推

循环总结

如何选择循环语句：
循环之间其实是都可以相互转换的，所以用哪种循环都可以。但是用的最多的是for循环,如果循环次数已知一般用for. while循环一般在循环次数未知的情况下使用,或者死循环一般都用while循环 do…while循环基本不用

25运算符

运算符： 用来在编程过中对各种数据进行处理运算的符号

算术运行符

其实就是常见的数学运行符，不过有些地方有点不同

符号	作用	不同之处
+	加	单纯使用数字参与运算的时候和数学中的+没有不同
-	减	无
*	乘	无
/	除	整数相除只能得到整数,如果想得到小数必须使用小数参与计算 例如: int num = 10/3； //num的值为3而不会是3.333
%	取余	获取的是两个数据做整除后得到的余数 int num = 10%3;

如果字符参与了运算：

​ char类型参与算术运算，会把字符转换成对应的数字（参照 ASCII 码表）然后参与运算。

char c = 'A';
System.out.println(c+0); 

如果字符串参与了+运算：

​ 当“+”操作中出现字符串时，这个”+”是会进行字符串的拼接，而不会进行数据的计算

System.out.println("夜半三更三更看了"+3+"遍小白船"); // 夜半三更三更看了3遍小白船

练习

1.尝试定义3个变量分别存储语文，数学，英语的分数，使用键盘输入的方式让用户输入对应的分数。然后去打印总分和平均分。

2.判断下面代码的执行结果

System.out.println('a'+10+"bc"+'d'+10);//107bcd10

赋值运算符

可以用来修改变量的值。赋值运行符左边写要被修改值的变量名，右边写参与计算的值,这个值可以是具体的值也可以是变量。

符号	功能	举例
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=10; //相当于a =(a的数据类型) (a + 10);
-=	减后赋值	a-=b;//相当于a =(a的数据类型) (a - b);
*=	乘后赋值	a*=b;//相当于a =(a的数据类型) (a * b);
/=	除后赋值	a/=b;//相当于a =(a的数据类型) (a / b);
%=	取余后赋值	a%=b;//相当于a =(a的数据类型) (a % b);

自增自减运算符

符号	作用	举例
++	自增	a++;//相当于a = a+1;
–	自减	a–;//相当于a = a - 1;

注意:

​ ++和–可以写在变量的前面也可以写在变量的后面,单独写的时候写前面写后面都没有区别.区别就在和其它运算符一起写.
​ ++写在变量前的时候先自增然后再参与其他运算
​ ++写在变量后面的时候先参与其它运算后自增

public class Demo03 {
    public static void main(String[] args) {
        int a = 10;
        int b = 10;
        int c = a++;
        int d = ++b;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);
    }
}

​ 爬山警告：如果想让领导带你去爬山的话，在公司中写代码的时候可以把自增自减运算符和其他运行放在一起使用。

例如：

		int a = 5;
        int c = 10;
        int b = 20;
        int d = ++a+b+++c+++(a+b);
        System.out.println(d);

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iVPmwVh0-1681564815839)(img\image-20200815164342314.png)]

比较运算符

让计算机帮我们去比较数值之间的关系是否正确。

==  比较左右两边是否相等,结果是布尔类型的
<    比较左边是否小于右边,结果是布尔类型
>    比较左边是否大于右边,结果是布尔类型
<=  比较左边是否小于等于右边,结果是布尔类型
>=  比较左边是否大于等于右边,结果是布尔类型
!=  比较左右两边是否不相等,如果不相等结果是true,否则是false

逻辑运算符

符号	作用	说明
&	逻辑与	理解成并且的意思，左右两边都要为真才为真
|	逻辑或	理解成或者的意思，左右两边只要有一个为真就为真
^	逻辑异或	左右两边不同结果才为真
!	逻辑非	取反
&&	短路与	作用和&相同，但是有短路效果
||	短路或	作用和|相同，但是有短路效果

你听懂了这个知识点 或者 你没听懂这个知识点

你是女生并且你是男生

短路效果：左边表达式的结果确定之后,如果整个表达式的结果已经被确定了,就不会去执行右边的表达式

例如：

int x = 10;
int y = 15;
//System.out.println((x++ > 4) | (y++ > 5)); // 两个表达都会运算
System.out.println((x++ > 4) || (y++ > 5)); // 左边已经可以确定结果为false，右边不参与运算

三元运算符

格式

布尔表达式?表达式1:表达式2;

执行流程

​ 先判断布尔表达式的结果,如果结果为true三元表达式的结果就是表达式1的值,否则就是表达式2的值。因为肯定会有一个结果。所以我们在使用的时候需要把这个结果使用(用变量保存，打印等)起来。不然就没有意义。

例如：

int a = 10;
int b = 20;
int result = a==b?a:b;
System.out.println(result);

练习

1.键盘录入两个数，求两个数中的最大值并打印

    public static void main(String[] args) {
//        键盘录入两个数，求两个数中的最大值并打印
        //键盘录入2个数
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int a = sc.nextInt();
        System.out.println("请输入第二个数");
        int b = sc.nextInt();
        //判断a>b嘛  ，如果成立 最大值就是a  负责就是b
        int result = a>b?a:b;
        System.out.println("最大值为"+result);
    }

26注释

注释是对代码的解释和说明，可以提高程序的可读性。它不会影响程序的运行结果。

无论是对于初学阶段还是以后的工作开发阶段，给代码添加注释都是非常有必要的。

格式

1.单行注释

单行注释的格式是使用//，从//开始至本行结尾的文字将作为注释的内容

例如：

//我写在双斜杠的后面，我是注释内容
你猜我是注释内容吗？
    
写字楼里写字间，
写字间里程序员。
程序人员写程序，
又拿程序换酒钱。

2.多行注释

多行注释的格式是使用/* 和 */将一段较长的注释括起来，即使中间的内容有多行也不会出问题。

例如：

/*
	我是多行注释，
	为了显示我的强大，
	我故意写成了多行,
	只要我被他们正确的包裹中，
	我就是注释
*/
/*我是多行注释，虽然我只有一行*/

3.文档注释

文档注释以/**开始，以*/结束。

/**
    我是神秘的文档注释，
    等你们学习了方法，我再让你看看我的强大。
 */

练习

①尝试用单行注释和多行注释去给我们的HelloWorld代码去加上解释说明。让他具有更强的可读性。

②尝试把下面这注释内容作为注释添加到自己的HelloWorld代码中。并且要保证代码能正常运行。

                              _ooOoo_
                             o8888888o
                             88" . "88
                             (| -_- |)
                             O\  =  /O
                          ____/`---'\____
                        .'  \\|     |//  `.
                       /  \\|||  :  |||//  \
                      /  _||||| -:- |||||-  \
                      |   | \\\  -  /// |   |
                      | \_|  ''\---/''  |   |
                      \  .-\__  `-`  ___/-. /
                    ___`. .'  /--.--\  `. . __
                 ."" '<  `.___\_<|>_/___.'  >'"".
                | | :  `- \`.;`\ _ /`;.`/ - ` : | |
                \  \ `-.   \_ __\ /__ _/   .-` /  /
           ======`-.____`-.___\_____/___.-`____.-'======
                              `=---='
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                      佛祖保佑        永无BUG
             佛曰:
                    写字楼里写字间，写字间里程序员；
                    程序人员写程序，又拿程序换酒钱。
                    酒醒只在网上坐，酒醉还来网下眠；
                    酒醉酒醒日复日，网上网下年复年。
                    但愿老死电脑间，不愿鞠躬老板前；
                    奔驰宝马贵者趣，公交自行程序员。
                    别人笑我忒疯癫，我笑自己命太贱；
                    不见满街漂亮妹，哪个归得程序员？

IDEA快捷键

功能	快捷方式
增加或取消单行注释	ctrl+/
增加或取消多行注释	ctrl+shift+/
文档注释	输入/**+enter

27字面值

在java代码中我们可以用一些值来代表一些数据。这些值就是字面值。

Java还对这些字值进行了一定的分类。

字面值分类

• 整数值 例如： 10 99 66
• 小数值 例如： 3.14 5.78
• 字符串值 用英文双引号包裹起来 例如: “三更草堂”
• 布尔值 用来表示真或假 只有两种值 true和false
• 空值 代表空值，我们后面会使用到 null

练习

再去看下我们之前写的HelloWrold的代码。看下里面有哪些是字面值。

然后去重新写个代码尝试输出各种类型的值。