尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)

开发环境:jdk17 + idea2022

第一阶段:Java基本语法

一、Java语言概述

01、Java新版视频教程简介

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第1张图片
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第2张图片
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第3张图片

02、课程目录说明

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第4张图片

03、Java基础全栈学习路线
04、抽茧剥丝话Java

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第5张图片

05、Java工程师全程学习路线

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第6张图片

06、计算机硬件的介绍
6.1 计算机组成:硬件+软件

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第7张图片

6.2 CPU、内存与硬盘

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第8张图片

6.3 输入设备:键盘输入

金山打字通

07、常见的DOS命令

DOS(Disk Operating System,磁盘操作系统)是Microsoft公司在Windows之前推出的一个操作系统,是单用户、单任务(即只能执行一个任务)的操作系统。现在被Windows系统取代。

进入DOS操作窗口:
按下Windows+R键盘,打开运行窗口,输入cmd回车,进入到DOS的操作窗口。

常用指令:
操作1:进入和回退

操作	说明
盘符名称:	盘符切换。E:回车,表示切换到E盘。
dir	列出当前目录下的文件以及文件夹
cd 目录	进入指定单级目录。
cd 目录1\目录2\...	进入指定多级目录。cd atguigu\JavaSE
cd ..	回退到上一级目录。
cd \ 或 cd /	回退到盘符目录。
操作2:增、删
操作	说明
md 文件目录名	创建指定的文件目录。
rd 文件目录名	删除指定的文件目录(如文件目录内有数据,删除失败)
操作3:其它
操作	说明
cls	清屏。
exit	退出命令提示符窗口。
← →	移动光标
↑ ↓	调阅历史操作命令
Delete和Backspace	删除字符
08、不同编程语言的介绍
8.1 计算机语言是什么

就是人与计算机交流的方式。人们可以使用编程语言对计算机下达命令,让计算机完成人们需要的功能。

计算机语言有很多种。如:C 、C++、Java、Go、JavaScript、Python,Scala等。

8.2 计算机语言简史

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第9张图片

高级语言独立于机器,有一定的通用性;计算机不能直接识别和执行用高级语言编写的程序,需要使用编译器或者解释器,转换为机器语言才能被识别和执行

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第10张图片
高级语言按照程序设计方法的不同,又分为:面向过程的语言、面向对象的语言。

  • 1.C、Pascal、Fortran面向过程的语言
  • 2.C++面向过程/面向对象
  • 3.Java跨平台的纯面向对象的语言
  • 4.C#、Python、JavaScript、Scala…
8.3 计算机语言排行榜

TIOBE (https://www.tiobe.com/tiobe-index/)流行编程语言排行,每月更新
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第11张图片

网传的编程语言鄙视链:
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第12张图片

09、Java相关历史
10、JDK的选择和下载

path 路径从上往下识别

11、 HelloWorld
11.1 开发步骤

Java程序开发三步骤:编写、编译、运行。

  • 将 Java 代码编写到扩展名为 .java 的源文件中
  • 通过 javac.exe 命令对该 java 文件进行编译,生成一个或多个字节码文件
  • 通过 java.exe 命令对生成的 class 文件进行运行
    尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第13张图片

HelloWorld

cmd  复制路径  右击粘贴

新建文件,后缀为 .java
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第14张图片
内容
编码格式 – ANSI

// 类  类名{}
class HelloChina{

}

cmd

C:\Users\stu>e:

E:\>cd E:\z_teach\javacode\chapter01

E:\z_teach\javacode\chapter01>javac HelloWorld.java

结果
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第15张图片
cmd

E:\z_teach\javacode\chapter01>java HelloChina
错误: 在类 HelloChina 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application

内容

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

重新运行

E:\z_teach\javacode\chapter01>javac HelloWorld.java

E:\z_teach\javacode\chapter01>java HelloChina

E:\z_teach\javacode\chapter01>

内容

class HelloChina{
	public static void main(String[] args){
		System.out.println("hello,world!!");
		System.out.println("你好,中国!!");
	}
}

重新运行

E:\z_teach\javacode\chapter01>javac HelloWorld.java

E:\z_teach\javacode\chapter01>java HelloChina
hello,world!!
你好,中国!!

内容

class HelloChina{
	public static void main(String[] args){
		System.out.println("hello,world!!");
		System.out.println("你好,中国!!");
	}
}

class  Lin{

}


class Yu{

}

重新运行

E:\z_teach\javacode\chapter01>javac HelloWorld.java

结果
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第16张图片

12.、HelloWorld总结

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第17张图片
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第18张图片
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第19张图片

13、注释

在这里插入图片描述
内容

/*
这是多行注释,可以声明多行注释的信息

1、Java中的注释的种类:
单行注释、多行注释、文档注释(Java特有)

2、单行注释、多行注释的作用:
①对程序中的代码进行解释说明
②对程序进行调试

3、注意:
① 单行注释和多行注释声明的信息不参与编译。换句话说,编译后声明的字节码文件中不包含单行注释和多行注释的信息
② 多行注释不能嵌套使用

4、文档注释
文档注释内容可以被JDK提供的工具 javadoc 所解析,生成一套以网页文件形式体现的该程序的说明文档。
*/

/**
这是我的第一个java程序

@author davina
@version 1.0
*/

public class CommentTest{
	/**
	这是main方法,格式是固定的
	*/
	/**
	这是main方法,格式是固定的(多行注释)
	*/
	public static void main(String[] args){
		//这是输出语句
		System.out.println("hello,world");
	} 
}

运行

E:\z_teach\javacode\chapter01>javadoc -d mydoc -author -version CommentTest.java

结果

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第20张图片
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第21张图片

14、 Java API文档

•下载API文档:

  • 在线看:https://docs.oracle.com/en/java/javase/17/docs/api/index.html
  • 离线下载:https://www.oracle.com/java/technologies/javase-jdk17-doc-downloads.html
15、Java核心机制:JVM
15.1 Java语言的优缺点
15.1.1 优点

跨平台性
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第22张图片

面向对象性:
面向对象编程支持封装、继承、多态等特性,让程序更好达到高内聚,低耦合的标准。
健壮性
吸收了C/C++语言的优点,但去掉了其影响程序健壮性的部分(如指针、内存的申请与释放等),提供了一个相对安全的内存管理和访问机制

15.1.2 缺点
  • 语法过于复杂、严谨,对程序员的约束比较多,与python、php等相比入门较难。但是一旦学会了,就业岗位需求量大,而且薪资待遇节节攀升。
  • 一般适用于大型网站开发,整个架构会比较重,对于初创公司开发和维护人员的成本比较高(即薪资高),选择用Java语言开发网站或应用系统的需要一定的经济实力。
  • 并非适用于所有领域
15.2 JVM功能说明

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第23张图片
JVM(Java Virtual Machine ,Java虚拟机):是一个虚拟的计算机,是Java程序的运行环境。JVM具有指令集并使用不同的存储区域,负责执行指令,管理数据、内存、寄存器。

15.2.1 功能1:实现Java程序的跨平台性

我们编写的Java代码,都运行在JVM 之上。正是因为有了JVM,才使得Java程序具备了跨平台性。

使用JVM前后对比:

15.2.2 功能2:自动内存管理(内存分配、内存回收)

•Java程序在运行过程中,涉及到运算的数据的分配、存储等都由JVM来完成
•Java消除了程序员回收无用内存空间的职责。提供了一种系统级线程跟踪存储空间的分配情况,在内存空间达到相应阈值时,检查并释放可被释放的存储器空间。
•GC的自动回收,提高了内存空间的利用效率,也提高了编程人员的效率,很大程度上减少了因为没有释放空间而导致的内存泄漏。

16、章节案例
案例1:个人信息输出

在这里插入图片描述
内容

class PersonalInfo{
	public static void main(String[] args){
		System.out.println("姓名:康师傅");
		System.out.println();  //换行
		System.out.println("性别:男");
		System.out.println("家庭住址:北京程序员聚集地:回龙观");
	} 
}

结果

E:\z_teach\javacode\chapter01>javac PersonalInfo.java

E:\z_teach\javacode\chapter01>java PersonalInfo
姓名:康师傅

性别:男
家庭住址:北京程序员聚集地:回龙观

E:\z_teach\javacode\chapter01>
案例2:输出:心形

结合\n(换行),\t(制表符),空格等在控制台打印出如下图所示的效果。
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第24张图片
方式一:
//方式一:

class Exercise2{
	public static void main(String[] args){
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("*");
		System.out.print("\t");
		//System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("I love java");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");
		
		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("    ");
		System.out.print("*");

	}

}

方式二:

class Exercise3{

	public static void main(String[] args){                                                                                                   
		System.out.print("\t"+"*"+"\t\t\t\t\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("*"+"\t\t"+"*"+"\t\t\t\t"+"I love Java"+"\t\t\t\t"+"*"+"\t\t\t"+"*"+"\n");
		System.out.print("\t"+"*"+"\t\t\t\t\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");

		System.out.print("\t\t"+"*"+"\t\t\t\t\t\t\t\t\t\t"+"*"+"\t\t"+"\n");

		System.out.print("\t\t\t"+"*"+"\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("\t\t\t\t"+"*"+"\t\t\t\t\t\t"+"*"+""+"\t"+"\n");
		System.out.print("\t\t\t\t\t"+"*"+"\t\t\t\t"+"*"+""+"\t\t"+"\n");
		System.out.print("\t\t\t\t\t\t"+"*"+"\t\t"+"*"+""+"\t\t"+"\n");
		System.out.print("\t\t\t\t\t\t\t"+"*"+"\n");


	}

}

17、随堂复习与企业真题

17.1、随堂复习
17.1.1、java基础全程的学习内容

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第25张图片

神书:《Java核心技术》、《effective java》、《java编程思想》

17.1.2、软件开发相关内容

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第26张图片
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第27张图片

没有最好的语言,只有在特地场景下相对来说,最适合的语言

17.1.3、java概述

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第28张图片

17.1.4、Java环境的搭建

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第29张图片

17.1.5、代码
17.1.6、常见问题
17.1.7、API文档
17.1.8、练习
17.2、企业真题

1、一个“.java”源文件中是否可以包括多个类?有什么限制(明*数据)
一个源文件中可以声明多个类,最多只有一个类使用public 进行声明。

但是一个源文件只能有一个public的类

2、java的优势()

  • 跨平台型
  • 安全性高
  • 简单性
  • 高性能
  • 面向对象性
  • 健壮性

3、常用的几个命令行操作都有哪些(至少4个)

4、java中是否存在内存溢出、内存泄漏?如何解决?举例说明(拼)**
存在
不能

5. 如何看待Java是一门半编译半解释型的语言
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第30张图片

二、变量与运算符

01、关键字、保留字
  • 定义:被Java语言赋予了特殊含义,用做专门用途的字符串(或单词)HelloWorld案例中,出现的关键字有 class、public 、 static 、 void 等,这些单词已经被Java定义好了。

特点:全部关键字都是小写字母。
关键字比较多,不需要死记硬背,学到哪里记到哪里即可。

官方地址

说明:
1.关键字一共50个,其中const和goto是保留字(reserved word)。
2.true,false,null不是关键字,是字面量,表示特殊的布尔值和空值,可以当做关键字来看待

保留字 :const、goto
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第31张图片
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第32张图片

02. 标识符( identifier)
  • 凡是自己可以起名字的地方都叫标识符。
  • 比如:类名、变量名、方法名、接口名、包名、常量名
2.1、标识符的命名规则(必须遵守的硬性规定):
  • 由26个英文字母大小写,0-9 ,_或 $ 组成
  • 数字不可以开头。
  • 不可以使用关键字和保留字,但能包含关键字和保留字。
  • Java中严格区分大小写,长度无限制。
  • 标识符不能包含空格。
2.2、标识符的命名规范
  • 包名:多单词组成时所有字母都小写:xxxyyyzzz。
    例如:java.lang、com.atguigu.bean

  • 类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
    例如:HelloWorld,String,System等

  • 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
    例如:age,name,bookName,main,binarySearch,getName

  • 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ
    例如:MAX_VALUE,PI,DEFAULT_CAPACITY

注意:在起名字时,为了提高阅读性,要尽量有意义,“见名知意”。

class IdentifierTest{
	public static void main(String[] args){
		
		int abc = 12;
		int age = 16;  //age:标识符
		
		char gender = '男';
	}
	
	public static void main1(String[] args){
	
	}
}
03. 变量(重点)
3.1、为什么需要变量

变量是程序中不可或缺的组成单位,最基本的存储单元。

3.2、初识变量

变量的概念:

  • 内存中的一个存储区域,该区域的数据可以在同一类型范围内不断变化
  • 变量的构成包含三个要素:数据类型、变量名、存储的值
  • Java中变量声明的格式:数据类型 变量名 = 变量值
class VariableTest{
	public static void main(String[] args){
		
		//定义变量的方式1
		char gender; 	//过程1:变量的声明
		gender = '男';	//过程2:变量的赋值(或初始化)
		
		gender = '女';	
		
		//定义变量的方式2:声明与初始化合并
		int age = 10;
		
		System.out.println("Hello World!");
		System.out.println(age);
		System.out.println("age = " + age);
	}
}
3.3、 Java中变量的数据类型

Java中变量的数据类型分为两大类:

  • 基本数据类型:包括 整数类型、浮点数类型、字符类型、布尔类型。
  • 引用数据类型:包括数组、 类、接口、枚举、注解、记录。
    尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第33张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第34张图片

3.4、变量的使用

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第35张图片

04. 基本数据类型介绍
4.1 整数类型:byte、short、int、long
4.2 浮点类型:float、double
/*
测试整型和浮点型变量的使用

*/
class VariableTest1{
	public static void main(String[] args){
		
		//1、测试整型变量的使用
		// byte(1字节 = 8bit) \ short(2字节 ) \ int(4字节) \ long(8字节)
		
		byte b1 = 12;
		byte b2 = 127;
		
		// byte b3 = 128;   //编译不通过,因为超出了byte的存储范围
		
		short s1 = 1234;
		
		int i1 = 123234123;
		//①声明long类型变量时,需要提供后缀,后缀为‘l’或'L'
		long l1 = 123123123L;	
		
		//②开发中,定义整型变量时,无特殊情况,通常声明为int类型
		
		
		//2、测试浮点型变量的使用
		// float \ double
		double d1 = 12.3;
		//①声明float类型变量时,需要提供后缀,后缀为‘f’或'F'
		float f1 = 12.3f;
		
		System.out.println("f1 = " + f1);
		
		//②开发中,定义浮点型变量时,无特殊情况,通常声明为double类型,因为精度更高
		
		//③ float 类型表数范围大于long类型的,但是精度不高
		
		//测试浮点型变量的精度,
		//浮点型变量的精度不高,需要精确数字计算或保留指定位数的精度,需要使用BigDecimal类。
		//测试1:
		System.out.println(0.1 + 0.2);
		
		//测试2:
		float ff1 = 123123123f;
		float ff2 = ff1 + 1;
		System.out.println(ff1);
		System.out.println(ff2);
		System.out.println(ff1 == ff2);
	}
}

java 计算金额时,使用 BigDecimal类替换,可以实现任意精度的数据的运算

4.2.1 关于浮点型精度的说明
  • 并不是所有的小数都能可以精确的用二进制浮点数表示。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。
  • 浮点类型float、double的数据不适合在不容许舍入误差的金融计算领域。如果需要精确数字计算或保留指定位数的精度,需要使用BigDecimal类。
4.2.2 应用举例

案例1:定义圆周率并赋值为3.14,现有3个圆的半径分别为1.2、2.5、6,求它们的面积。

class FloatDoubleExer{
	public static void main(String[] args){
		
		//定义圆周率变量
		double pi = 3.14;
		
		//定义三个圆的半径
		double radius1 = 1.2;
		double radius2 = 2.5;
		double radius3 = 6;
		
		//计算面积
		double area1 = pi * radius1 * radius1;
		double area2 = pi * radius2 * radius2;
		double area3 = pi * radius3 * radius3;
		
		//输出
		System.out.println("圆1的半径为: " + radius1 + ",面积为:" + area1);
		System.out.println("圆2的半径为: " + radius2 + ",面积为:" + area2);
		System.out.println("圆3的半径为: " + radius3 + ",面积为:" + area3);
	}
}

**案例2:**小明要到美国旅游,可是那里的温度是以华氏度为单位记录的。 它需要一个程序将华氏温度(80度)转换为摄氏度,并以华氏度和摄氏度为单位分别显示该温度。

// ℃ = (℉ - 32) / 1.8

public class Exercise2 {
    public static void main(String[] args) {
        double hua = 80;
        double she = (hua-32)/1.8;
        System.out.println("华氏度" + hua+"℉转为摄氏度是" +she+"℃");
    }
}
4.3、字符类型:char

char使用的是Unicode字符集,包含了世界范围的所有字符

class CharTest{
	public static void main(String[] args){
		
		//形式1:使用单引号(' ')括起来的单个字符。
		char c1 = 'a'; 
		char c2 = '中'; 
		char c3 = '1';
		char c4 = '%';
		char c5 = 'Y';
		
		//编译不通过
		//char c6 = '';
		//char c7 = 'ab';
		
		//形式2:直接使用 Unicode值来表示字符型常量
		char c8 = '\u0036';
		System.out.println(c8);	
		
		//形式3:使用转义字符‘\’
		char c9 = '\n';  // '\n'表示换行符
		char c10 = '\t';
		System.out.println("hello" + c9 + "world");	
		
		//形式4:使用具体字符对应的数值(比如ASCII码)
		char c11 = 97;
		System.out.println(c11);	// a 
		
		char c12 = '1';
		char c13 = 1; //两者不相等
	}
}	
4.4、布尔类型:boolean

boolean类型数据只有两个值:true、false

boolean 类型用来判断逻辑条件,一般用于流程控制语句中:

  • if条件控制语句;
  • while循环控制语句;
  • for循环控制语句;
  • do-while循环控制语句;
class BooleanTest{
	public static void main(String[] args){		
		// 布尔类型:boolean
		boolean bo1 = true;
		boolean bo2 = false;
		
		//boolean 类型用来判断逻辑条件,一般用于流程控制语句中:
		boolean isMarried = true;
		if(isMarried){
			System.out.println("很遗憾,不能参加单身派对了");
		}else{
			System.out.println("可以多谈几个男朋友或女朋友");
		}
		
		//不谈boolean类型占用空间的大小,都是,真正在内存中分配的话,使用的是4个字节		
	}
}	

05、基本数据类型变量间运算规则

1、在Java程序中,不同的基本数据类型(只有7种,不包含boolean类型)变量的值经常需要进行相互转换。
2、转换的方式有两种:
自动类型提升
强制类型转换

5.1 自动类型提升

规则:将取值范围小(或容量小)的类型自动提升为取值范围大(或容量大)的类型
在这里插入图片描述

/*

取值范围小(或容量小)的类型自动提升为取值范围大(或容量大)的类型 。

特别的:
	byte,short,char数据类型的变量进行算术运算时,结果按照int类型处理。
*/

class VariableTest3{
	public static void main(String[] args){
		
		int i1 = 10;
		int i2 = 11;
		
		long l1 = i1;
		
		float f1 = l1;
		
		byte b1 = 12;
		int i3 = b1 + i1;
		
		//编译不通过
		//byte b2 = b1 + i1;
		
		//特殊情况1:byte,short之间运算
		byte b3 = 12;
		short s1 = 10;
		//编译不通过
		//short s2 = b3 + s1;
		i3 = b3 + s1;
		
		byte b4 = 10;
		int i4 = b3 + b4;
		
		//特殊情况2:char
		char c1 = 'a';
		//编译不通过
		//char c2 = c1 + b3;
		int i5 = c1 + b3;

		//**************************************
		//练习1
		long l2 = 123L;
		long l3 = 123;  //理解为:自动类型提升
		
		//long l4 = 123123123123; //123123123123理解为int类型,因为超出了int范围,所以报错
		long l5 = 123123123123L; //此时的123123123123L就是使用8个字节存储的long类型的值
		
		//练习2
		float f2 = 12.3F;
		//float f3 = 12.3; //不满足自动类型提升的规则(double --> float ),所以报错
	
		//练习3
		//规定1:整型常量,规定是int类型
		byte b5 = 10;
		//byte b6 = b5 + 1;
		int i11 = b5 + 1;
		
		//规定2:浮点型常量,规定是double类型
		double d2 = b5 + 12.3;
		
		//练习4:为什么不允许变量名是数字开头。为了"自洽"
		/*
		int 123L = 12;
		long l6 = 123L;
		*/		
	}
}	
5.2 强制类型转换

规则:将取值范围大(或容量大)的类型强制转换成取值范围小(或容量小)的类型。
转换格式:
数据类型1 变量名 = (数据类型1)被强转数据值; //()中的数据类型必须<=变量值的数据类型

当把存储范围大的值(常量值、变量的值、表达式计算的结果值)强制转换为存储范围小的变量时,可能会损失精度或溢出。

class VariableTest4{
	public static void main(String[] args){
		
		double d1 = 12; //自动类型提升
		
		//编译不通过
		//int i1 = d1;
		
		int i2 = (int)d1;
		System.out.println(i2);
		
		long l1 = 123;
		
		//编译不通过
		//short s1 = l1;
		
		short s2 = (short)l1;
		System.out.println(s2);
		
		//练习
		int i3 = 12;
		float f1 = i3; //自动类型提升
		System.out.println(f1); // 12.0
		
		float f2 = (float)i3; //编译可以通过,省略()而已

		//精度损失的例子1
		double d2 = 12.9;
		int i4 = (int)d2;
		System.out.println(i4);
		
		//精度损失的例子2
		int i5 = 128;
		byte b1 = (byte)i5;
		System.out.println(b1); //-128
	
		//实际开发举例
		byte b2 = 12;
		method(b2);
		
		long l2 = 12L;
		//编译不通过
		//method(l2);
		method((int)l2);
	}
	
	public static void method(int num){	//int num = b2; 自动类型提升
		System.out.println("num = " + num);
	} 
}	
5.3 基本数据类型与String的运算
5.3.1 字符串类型:String

String不是基本数据类型,属于引用数据类型
使用一对""来表示一个字符串,内部可以包含0个、1个或多个字符。
声明方式与基本数据类型类似。例如:String str = “尚硅谷”;

class StringTest{
	public static void main(String[] args){
		String str1 = "Hello World!";
		System.out.println("str1");
		System.out.println(str1);
		
		
		String str2 = "";
		String str3 = "a";	
	}
}	
5.3.2 运算规则
/*
测试强制类型转换

*/
class StringTest{
	public static void main(String[] args){
		String str1 = "Hello World!";
		System.out.println("str1");
		System.out.println(str1);
		
		
		String str2 = "";
		String str3 = "a";	
		
		
		//测试连接运算
		int num1 = 10;
		boolean b1 = true;
		String str4 = "hello";
		
		System.out.println(str4 + b1); //hellotrue
		
		String str5 = str4 + b1;
		String str6 = str4 + b1 + num1;
		System.out.println(str6); //hellotrue10
		
		//如何将String 类型转换为基本数据类型
		String str7 = "abc"; //不能考虑转换为基本数据类型
		
		int num2 = 10;
		String str8 = num2 + ""; "10"
		//编译不通过
		//int num3 = (int)str8;
		
		//使用Integer类
		int num3 = Integer.parseInt(str8);
		System.out.println(str8);
	}
}	
5.3.3 案例与练习

案例:公安局身份登记
要求填写自己的姓名、年龄、性别、体重、婚姻状况(已婚用true表示,单身用false表示)、联系方式等等。

class StringExer{
	public static void main(String[] args){	
		
		String name = "莉莉";
		int age = 18;
		char gender = '女';
		double weight = 99.1;
		boolean isMarried = false;
		String phoneNumber = "1234567890";
		
		System.out.println("姓名: " + name + ",年龄:" + age + ",性别: " + gender + ",体重: " + weight + ",婚姻状况:" + isMarried + ",联系方式: " + phoneNumber);
	}
}
06、进制的认识

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第36张图片

  • 二进制(binary)(以0B、0b开头)、十进制、八进制(以0开头)、十六进制(以0x、0X开头)的声明方式
  • 二进制的理解
  • 正数:原码、反码、补码三码合一
  • 负数:原码、反码、补码不相同。
  • 计算机的底层是以补码的方式存储数据的
  • 熟悉:二进制与十进制之间的转换
  • 了解:二进制与八进制、十六进制之间的转换
07、运算符(Operator)(重点)
7.1 算术运算符

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第37张图片

7.1.1 基本语法

++ 或 – 不会改变数据类型

class AriTest {
	public static void main(String[] args){	
	
	//-------------------------------------------------------------------------------
		// 除法:/
		int m1 = 12;
		int n1 = 5;
		int k1 = m1 / n1;  
		System.out.println(k1);  //2 
		
		System.out.println(m1 / n1 * n1); //10 
		
		//取模(或取余) : %
		int i1 = 12;
		int j1 = 5;
		System.out.println(i1 % j1); //2 
		
		//开发中,经常用来判断某个数num1能整除另外一个数num2。 num1 % num2 == 0 
		//比如判断num1是否是偶数: num1 % num2 == 0 
		
		//取模后,结果与被模数符号相同
		int i2 = -12;
		int j2 = 5;
		System.out.println(i2 % j2); //-2 
		
		int i3 = 12;
		int j3 = -5;
		System.out.println(i3 % j3); //2 
		
		int i4 = -12;
		int j4 = -5;
		System.out.println(i4 % j4); //-2 
		

	//-------------------------------------------------------------------------------
		//(前)++:先自增1,再运算
		//(后)++:先运算,再自增1
		int a1 = 10;
		int b1 = ++a1;	
		System.out.println("a1 = " + a1 + ", b1 = " + b1);  // a1 = 11,b1 = 11
		
		int a2 = 10;
		int b2 = a2++;	
		System.out.println("a2 = " + a2 + ", b2 = " + b2); // a2 = 11,b2 = 10
		
		//练习1
		int i = 10;
		// i++;
		++i;
		System.out.println("i = " + i); // 11
		
		//练习2
		short s1 = 10;
		
		//方式1
		/*
		//编译不通过
		//s1 = s1 + 1;
		s1 = (short)(s1 + 1);
		System.out.println(s1);
		*/
		
		//方式2 
		s1++;
		System.out.println(s1);
		
	//-------------------------------------------------------------------------------
		//(前)--:先自减1,再运算
		//(后)--:先运算,再自减1
		
		//+:连接符,只适用于String与其他类型的变量间的运算,而且运算结果也是String类型
	}	
}

7.1.2 案例与练习

案例1:
随意给出一个整数,打印显示它的个位数,十位数,百位数的值。
格式如下:
数字xxx的情况如下:
个位数:
十位数:
百位数:

例如:
数字153的情况如下:
个位数:3
十位数:5
百位数:1

class AriExer {
	public static void main(String[] args){	
		
		int num = 153;
		int ge = num % 10; // 个位
		int shi = num / 10 % 10; //十位
		int bai = num / 100; //百位
		
		System.out.println("个位是: " + ge);
		System.out.println("十位是: " + shi);
		System.out.println("百位是: " + bai);
	}
}

案例2:
为抵抗洪水,战士连续作战89小时,编程计算共多少天零多少小时?

class AriExer1 {
	public static void main(String[] args){	
		int num = 89;
		int day = num / 24; 
		int hour = num % 24;
		
		System.out.println("共奋战: " + day + "天零" + hour + "小时");	
	}
}

额外案例1

System.out.println("5 + 5= " + 5 + 5);  // 5 + 5= 55
System.out.println("5 + 5= " + (5 + 5)); // 5 + 5= 10

** 额外案例2**

byte bb1 = 127;
bb1++;
System.out.println("bb1 = " + bb1);//-128

** 额外案例3**

int i = 1;
int j = i++ + ++i * i++;
System.out.println("j = " + j); //10

** 额外案例4**

int i = 2;
int j = i++;
System.out.println(j);  //2

int k = 2;
int z = ++k;
System.out.println(z);  //3

int m = 2;
m = m++; 
System.out.println(m);  //2
7.2 赋值运算符
7.2.1 基本语法

= 、+=、 -=、*=、 /=、%=

/*
当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制类型转换原则进行处理。


*/	

class SetValueTest {
	public static void main(String[] args){
		int i = 5;
		
		long l = 10; //	自动类型提升
		
		byte b = (byte)i; //强制类型转换
	
		//操作方式1
		int a1 = 10;
		int b1 = 10;
		
		//操作方式2:连续赋值
		int a2;
		int b2;
		//或合并:int a2,b2;
		a2 = b2 = 10;
		
		System.out.println(a2 + "," + b2);
		
		
		//操作方式3:
		//int a1 = 20;
		//int b1 = 20;
		int a2 = b2 = 20;		
		System.out.println(a3 + "," + b3);
		
	//-------------------------------------------------------------------------------
		// += 的使用
		int m1 = 10;
		m1 += 5; 
		// 类似于 m1 = m1 + 5;
		System.out.println(m1);
		
		byte by1 = 10;
		by1 += 5;  //by1 = by1 + 5; 会编译报错,改为 by1 = (byte)(by1 + 5); 
		System.out.println(by1);
		
		int m2 = 1;
		m2 *= 0.1;  //m2 = (int)(m2 * 0.1)
		System.out.println(m2);
		
		//练习1:如何实现一个变量的值增加2 
		//方式1
		int n1 = 10;
		n1 = n1 + 2;
		
		//方式2(推荐)
		int n2 = 10;
		n2 += 2;
		
		//练习2:如何实现一个变量的值增加1 
		//方式1
		int i1 = 10;
		i1 = i1 + 1;
		
		//方式2
		int i2 = 10;
		i2 += 1;
		
		//方式3:(推荐)
		int i3 = 10;
		i3++; // ++i3;
	}
}	
7.3 比较(关系)运算符

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第38张图片
•比较运算符的结果都是boolean型,也就是要么是true,要么是false。
•> < >= <= :只适用于基本数据类型(除boolean类型之外)
== != :适用于基本数据类型和引用数据类型
•比较运算符“==”不能误写成“=”

class CompareTest {
	public static void main(String[] args) {
		int i1 = 10;
		int i2 = 20;
		
		System.out.println(i1 == i2);//false
		System.out.println(i1 != i2);//true
		System.out.println(i1 >= i2);//false


		int m = 10;
		int n = 20;
		System.out.println(m == n);//false
		System.out.println(m = n);//20

		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2);//false
		System.out.println(b1 = b2);//true
	}
}
7.4 逻辑运算符

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第39张图片

逻辑运算符,操作的都是boolean类型的变量或常量,而且运算得结果也是boolean类型的值

public class LogicTest {
	public static void main(String[] args) {	
	
		/*
		区分:& 和 &&
		
		–相同点:两个符号表达的都是且的关系,如果符号左边是true,则二者都执行符号右边的操作
		–不同点:& : 如果符号左边是false,则继续执行符号右边的操作
  && :如果符号左边是false,则不再继续执行符号右边的操作

–建议:开发中,推荐使用 && 
		*/
		
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		
		if(b1 & (num1++ >0)){
			System.out.println("床前明月光");
		}else{
			System.out.println("我叫郭德纲");
		}
		System.out.println("num1 = " + num1);
		
		
		
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		
		if(b2 && (num2++ >0)){
			System.out.println("床前明月光");
		}else{
			System.out.println("我叫郭德纲");
		}
		System.out.println("num2 = " + num2);
	}
}	
	

区分“|”和“||”:
— 相同点:如果符号左边是false,则二者都执行符号右边的操作
— 不同点:| : 如果符号左边是true,则继续执行符号右边的操作
|| :如果符号左边是true,则不再继续执行符号右边的操作
建议:开发中,推荐使用 ||

/*
	1. 定义类 LogicExer
	2. 定义 main方法
	3. 定义一个int类型变量a,变量b,都赋值为20
	4. 定义boolean类型变量bo1 , 判断++a 是否被3整除,并且a++ 是否被7整除,将结果赋值给bo1
	5. 输出a的值,bo1的值
	6. 定义boolean类型变量bo2 , 判断b++ 是否被3整除,并且++b 是否被7整除,将结果赋值给bo2
	7. 输出b的值,bo2的值
*/

public class LogicExer {
        public static void main(String[] args) {
            int a,b;
            a = b = 20;

            boolean bo1 = (++a % 3 == 0) && (a++ % 7 == 0);

            System.out.println("a = " + a + ",bo1 = " + bo1);

            boolean bo2 = (b++ % 3 == 0) && (++b % 7 == 0);

            System.out.println("b = " + b + ",bo2 = " + bo2);
    }
}
7.5 位运算符

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第40张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第41张图片

/*
位运算符

1、 <<   >>  >>>     &   \   ^   ~

2、说明
①<<   >>  >>>     &   \   ^   ~    针对数值类型的变量或常量进行运算,运算结果也是数值
②<<  每向左移动一位,相当于原数据*2。(正数、负数都适用)
  >>  每向右移动一位,相当于原数据/2。    【注意】如果不能整除,向下取整。
 >>>   往右移动后,左边空出来的位直接补0。(正数、负数都适用)
 &    对应位都是1才为1,否则为0。
*/

class BitTest{
    public static void main(String[] args) {
        int num1 = 7;
        System.out.println("num1 << 1 : " + (num1 << 1));  //num1 << 1 : 14
        System.out.println("num1 << 2 : " + (num1 << 2)); // num1 << 2 : 28
        System.out.println("num1 << 3 : " + (num1 << 3)); // num1 << 3 : 56
        System.out.println("num1 << 28 : " + (num1 << 28)); //num1 << 28 : 1879048192
        System.out.println("num1 << 29 : " + (num1 << 29)); //num1 << 29 : -536870912   过犹不及

        int num2 = -7;
        System.out.println("num2 << 1 : " + (num2 << 1));  //num2 << 1 : -14
        System.out.println("num2 << 2 : " + (num2 << 2)); // num2 << 2 : -28
        System.out.println("num2 << 3 : " + (num2 << 3)); // num2 << 3 : -56

        //面试题:高效计算 2 * 8
        // 2 << 3 或 8 << 1


        //69>>4  类似于  69/2的4次 = 69/16 =4
        System.out.println(69 >> 4);  //4

        System.out.println(62 >>> 3); //7

        System.out.println(5 & 3);
    }
}
//如何交换两个int型变量的值?String呢?
 class BitExer {
    public static void main(String[] args) {
        int m = 10;
        int n = 5;

        System.out.println("m = " + m + ", n = " + n);

        //(推荐)实现方式1:优点:容易理解,适用于不同数据类型    缺点:需要额外定义变量
        //int temp = m;
        //m = n;
        //n = temp;

        //实现方式2:优点:没有额外定义变量    缺点:可能超出int的范围;只能适用于数值类型
        //m = m + n; //15 = 10 + 5
        //n = m - n;//10 = 15 - 5
        //m = m - n;//5 = 15 - 10

        //实现方式3:优点:没有额外定义变量    缺点:不易理解;只能适用于数值类型
        m = m ^ n;
        n = m ^ n; //(m ^ n) ^ n
        m = m ^ n;

        System.out.println("m = " + m + ", n = " + n);
    }
}
7.6 条件运算符
7.6.1 基本语法

条件运算符格式:
(条件表达式)? 表达式1:表达式2
说明:条件表达式是boolean类型的结果,根据boolean的值选择表达式1或表达式2
要求表达式1和表达式2为同种或兼容的类型

7.6.2 案例
class ConditionTest{
    public static void main(String[] args) {

        String info = (2 > 10)?  "表达式1" : "表达式2";
        System.out.println(info);

        double result = (2 > 1)? 1 : 2.0;
        System.out.println(result);

        //练习1:获取两个数中的较大值
        int m = 10;
        int n = 20;

        int max = (m > n)? m : n;
        System.out.println("较大值为:" + max);

        //练习2:获取三个数中的较大值
        int i = 20;
        int j = 30;
        int k = 50;

        int temp = (i > j)? i : j;
        int  finalMax = (temp > k)? temp : k;
        System.out.println("较大值为:" + finalMax);

        int finalMax1 = (((i > j)? i : j) > k)? ((i > j)? i : j) : k;
        System.out.println("较大值为:" + finalMax1);
    }
}
/*
  练习:今天是周2,10天以后是周几?
 */
class ConditionExer{
    public static void main(String[] args) {

        int week = 2;

        week += 10;

        week %= 7;

        System.out.println("今天是周2,10天以后是周" + ((week == 0)? "日" : week) );
    }
}
7.6.3 与if-else的转换关系

凡是可以使用条件运算符的地方,都可以改写为if-else结构。反之,不成立

开发中,如果既可以使用条件运算符,又可以使用if-else,推荐使用条件运算符。因为执行效率稍高

7.7 运算符优先级

运算符有不同的优先级,所谓优先级就是在表达式运算中的运算符顺序。
上一行中的运算符总是优先于下一行的。

优先级 运算符说明 Java运算符
1 括号 ()、[]、{}
2 正负号 +、-
3 单元运算符 ++、–、~、!
4 乘法、除法、求余 *、/、%
5 加法、减法 +、-
6 移位运算符 <<、>>、>>>
7 关系运算符 <、<=、>=、>、instanceof
8 等价运算符 ==、!=
9 按位与 &
10 按位异或 ^
11 按位或
12 条件与 &&
13 条件或
14 三元运算符 ? :
15 赋值运算符 =、+=、-=、*=、/=、%=
16 位赋值运算符 &=、

开发建议:
1.不要过多的依赖运算的优先级来控制表达式的执行顺序,这样可读性太差,尽量使用()来控制表达式的执行顺序。
2.不要把一个表达式写得过于复杂,如果一个表达式过于复杂,则把它分成几步来完成。例如: (num1 + num2) * 2 > num3 && num2 > num3 ? num3 : num1 + num2;

三、流程控制语句

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第42张图片

01、顺序结构

程序从上到下逐行地执行,中间没有任何判断和跳转

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第43张图片

package testOne;

public class StatementTest {
    public static void main(String[] args) {
        int x = 1;
        int y = 2;
        System.out.println("x = " + x);
        System.out.println("y = " + y);

        //对x、y的值进行修改
        x++;
        y = 2 * x + y;
        x = x * 10;
        System.out.println("x = " + x);
        System.out.println("y = " + y);
    }
}
02、分支语句
  • 根据条件,选择性地执行某段代码。
  • 有if…else和switch-case两种分支语句
2.1 if-else条件判断结构
2.1.1 基本语法

结构1:单分支条件判断:if

格式:

if(条件表达式){
  	语句块;
}

说明:条件表达式必须是布尔表达式(关系表达式或逻辑表达式)或 布尔变量。

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第44张图片

结构2:双分支条件判断:if…else
格式:

if(条件表达式) { 
  	语句块1;
}else {
  	语句块2;
}

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第45张图片

结构3:多分支条件判断:if…else if…else
格式:

if (条件表达式1) {
  	语句块1;
} else if (条件表达式2) {
  	语句块2;
}
...
}else if (条件表达式n) {
 	语句块n;
} else {
  	语句块n+1;
}

说明:一旦条件表达式为true,则进入执行相应的语句块。执行完对应的语句块之后,就跳出当前结构
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第46张图片

当条件表达式之间是“互斥”关系时(即彼此没有交集),条件判断语句及执行语句间顺序无所谓。
当条件表达式之间是“包含”关系时,“小上大下 / 子上父下”,否则范围小的条件表达式将不可能被执行。

2.1.2 应用举例

案例1:成年人心率的正常范围是每分钟60-100次。体检时,如果心率不在此范围内,则提示需要做进一步的检查。

public class IfElseTest1 {
    public static void main(String[] args){
        int heartBeats = 89;

        if(heartBeats < 60 || heartBeats > 100){
            System.out.println("你需要做进一步的检查");
        }

        System.out.println("体检结束");
    }
}

案例2:定义一个整数,判定是偶数还是奇数

public class IfElseTest2 {
    public static void main(String[] args){
        int a = 10;

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

案例3:
岳小鹏参加Java考试,他和父亲岳不群达成承诺:
如果:
成绩为100分时,奖励一辆跑车;
成绩为(80,99]时,奖励一辆山地自行车;
当成绩为[60,80]时,奖励环球影城一日游;
其它时,胖揍一顿。

说明:默认成绩是在[0,100]范围内

public class IfElseTest3 {
    public static void main(String[] args) {

        int score = 67;//岳小鹏的期末成绩
        //写法一:默认成绩范围为[0,100]
        if(score == 100){
            System.out.println("奖励一辆跑车");
        }else if(score > 80 && score <= 99){    //错误的写法:}else if(80 < score <= 99){
            System.out.println("奖励一辆山地自行车");
        }else if(score >= 60 && score <= 80){
            System.out.println("奖励环球影城玩一日游");
        }
        //else{
        //	System.out.println("胖揍一顿");
        //}


        //写法二:
        // 默认成绩范围为[0,100]
        if(score == 100){
            System.out.println("奖励一辆跑车");
        }else if(score > 80){
            System.out.println("奖励一辆山地自行车");
        }else if(score >= 60){
            System.out.println("奖励环球影城玩一日游");
        }else{
            System.out.println("胖揍一顿");
        }
    }
}
2.1.3 if…else嵌套

在 if 的语句块中,或者是在else语句块中,又包含了另外一个条件判断(可以是单分支、双分支、多分支),就构成了嵌套结构。

执行的特点:
(1)如果是嵌套在if语句块中的,只有当外部的if条件满足,才会去判断内部的条件
(2)如果是嵌套在else语句块中的,只有当外部的if条件不满足,进入else后,才会去判断内部的条件

案例4:由键盘输入三个整数分别存入变量num1、num2、num3,对它们进行排序(使用 if-else if-else),并且从小到大输出。

import java.util.Scanner;

public class StatementTest {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        System.out.println("输入第1个整数: " );
        int num1 = in.nextInt();
        System.out.println("输入第2个整数: " );
        int num2 = in.nextInt();
        System.out.println("输入第3个整数: ");
        int num3 = in.nextInt();

        if(num1 >= num2){
            if (num3 >= num1){
                System.out.println(num2 + "," + num1 + "," + num3);
            }else if(num3 <= num2){
                System.out.println(num3 + "," + num2 + "," + num1);
            }else {
                System.out.println(num2 + ',' + num3 + ',' + num1);
            }
        }else {
            if (num3 >= num2){
                System.out.println(num2 + "," + num3 + "," + num1);
            }else if(num3 <= num1){
                System.out.println(num3 + "," + num1 + "," + num2);
            }else {
                System.out.println(num1 + ',' + num3 + ',' + num2);
            }
        }
    }
}
2.1.4 练习

练习1:

对下列代码,若有输出,指出输出结果

int x = 4;
int y = 1;
if (x > 2) {
       if (y > 2) 
            System.out.println(x + y);
       System.out.println("atguigu");
} else
       System.out.println("x is " + x);

练习2:

boolean b = true;
//如果写成if(b=false)能编译通过吗?如果能,结果是?
if(b == false) 	 //建议:if(!b)
	System.out.println("a");
else if(b)
	System.out.println("b");
else if(!b)
	System.out.println("c");
else
	System.out.println("d");

练习3:

定义两个整数,分别为small 和 big,如果第一个整数small大于第二个整数big,就交换。输出显示small和big变量的值。

    public static void main(String[] args) {
        int small = 10;
        int big = 30;

        if(small > big){
            int tmp = small;
            small = big;
            big = tmp;
        }
        System.out.println(small + " 、 "+ big);
    }

练习4:

小明参加期末Java考试,通过考试成绩,判断其Java等级,成绩范围[0,100]

  • 90-100 优秀
  • 80-89 好
  • 70-79 良
  • 60-69 及格
  • 60以下 不及格
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        System.out.println("小明的期末Java成绩是: ");
        int score = scan.nextInt();

        if (score < 0 || score > 100) {
            System.out.println("你的成绩是错误的");
        }else if(score >= 90){
            System.out.println("你的成绩属于优秀");
        }else if (score >= 80) {
            System.out.println("你的成绩属于好");
        } else if (score >= 70) {
            System.out.println("你的成绩属于良");
        } else if (score >= 60) {
            System.out.println("你的成绩属于及格");
        } else {
            System.out.println("你的成绩属于不及格");
        }
    }

练习5:

编写程序,声明2个int型变量并赋值。判断两数之和,如果大于等于50,打印“hello world!”

    public static void main(String[] args) {
        int a = 20;
        int b = 90;
        if(a + b >= 50){
            System.out.println("hello world!");
        }
    }

练习6:

编写程序,声明2个double型变量并赋值。判断第一个数大于10.0,且第2个数小于20.0,打印两数之和。否则,打印两数的乘积。

    public static void main(String[] args) {
    
        double num1 = 21.0;
        double num2 = 19.0;

        if (num1 > 10.0 && num2 < 20.0){
            System.out.println(num1 + num2);
        }else {
            System.out.println(num1 * num2);
        }
    }

练习7:判断水的温度

如果大于95℃,则打印“开水”;
如果大于70℃且小于等于95℃,则打印“热水”;
如果大于40℃且小于等于70℃,则打印“温水”;
如果小于等于40℃,则打印“凉水”。

    public static void main(String[] args) {
        int waterTemperature = 62;
        if (waterTemperature > 95){
            System.out.println("开水");
        }else if (waterTemperature >70){
            System.out.println("热水");
        }else if (waterTemperature > 40){
            System.out.println("温水");
        }else {
            System.out.println("凉水");
        }
    }
2.2 switch-case 选择结构
2.2.1 基本语法

语法格式

switch(表达式){
    case 常量值1:
        执行语句1;
        //break;
    case 常量值2:
        执行语句2;
        //break; 
    // ...
   [default:
        执行语句n+1;
        break;
   ]
}

执行流程图
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第47张图片
执行过程

  • 第1步:根据switch中表达式的值,依次匹配各个case。如果表达式的值等于某个case中的常量值,则执行对应case中的执行语句。
  • 第2步:执行完此case的执行语句以后,
    • 情况1:如果遇到break,则执行break并跳出当前的switch-case结构
    • 情况2:如果没有遇到break,则会继续执行当前case之后的其它case中的执行语句。—>case穿透 … 直到遇到break关键字或执行完所有的case及default的执行语句,跳出当前的switch-case结构
public class SwitchCaseTest {
    public static void main(String[] args) {

        int num = 1;
        switch (num){
            case 0:
                System.out.println("zero");
                break;
            case 1:
                System.out.println("one");
                break;
            case 2:
                System.out.println("two");
                break;
            case 3:
                System.out.println("three");
                break;
             default:
                 System.out.println("other");
                 break;
        }
    }
}
public class SwitchCaseTest2 {
    public static void main(String args[]) {
        String season = "summer";
        switch (season) {
            case "spring":
                System.out.println("春暖花开");
                break;
            case "summer":
                System.out.println("夏日炎炎");
                break;
            case "autumn":
                System.out.println("秋高气爽");
                break;
            case "winter":
                System.out.println("冬雪皑皑");
                break;
            default:
                System.out.println("季节输入有误");
                break;
        }
    }
}

使用注意点:

  • switch(表达式)中表达式的值必须是下述几种类型之一:byte,short,char,int,枚举 (jdk 5.0),String (jdk 7.0);
  • case子句中的值必须是常量,不能是变量名或不确定的表达式值或范围;
  • 同一个switch语句,所有case子句中的常量值互不相同;
  • break语句用来在执行完一个case分支后使程序跳出switch语句块;
  • 如果没有break,程序会顺序执行到switch结尾;
  • default子句是可选的。同时,位置也是灵活的。当没有匹配的case时,执行default语句。
2.2.2 if-else语句与switch-case语句比较
  • 结论:凡是使用switch-case的结构都可以转换为if-else结构。反之,不成立。
  • 开发经验:如果既可以使用switch-case,又可以使用if-else,建议使用switch-case。因为效率稍高。
  • 细节对比:
    • if-else语句优势
      • if语句的条件是一个布尔类型值,if条件表达式为true则进入分支,可以用于范围的判断,也可以用于等值的判断,使用范围更广。
      • switch语句的条件是一个常量值(byte,short,int,char,枚举,String),只能判断某个变量或表达式的结果是否等于某个常量值,使用场景较狭窄。
    • switch语句优势
      • 当条件是判断某个变量或表达式是否等于某个固定的常量值时,使用if和switch都可以,习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时,只能使用if语句。
      • 使用switch可以利用穿透性,同时执行多个分支,而if…else没有穿透性。
2.2.3 案例

案例1
使用switch-case实现:对学生成绩大于60分的,输出“合格”。低于60分的,输出“不合格”。

public class SwitchCaseTest {
    public static void main(String[] args) {

        int score = 99;

        switch (score/60){
            case 0:
                System.out.println("不及格");
                break;
            case 1:
                System.out.println("及格");
                break;
            default:
                System.out.println("输入的成绩有误");
                break;
        }
    }
}



switch(score / 10){
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			case 5:
				System.out.println("不及格");
				break;
			case 6:
			case 7:
			case 8:
			case 9:
			case 10:
				System.out.println("及格");
				break;
			default:
				System.out.println("输入的成绩有误");
				break;
		}

案例2
编写程序:从键盘上输入2023年的“month”和“day”,要求通过程序输出输入的日期为2023年的第几天。

import java.util.Scanner;

public class SwitchCaseTest {



    public static void main(String[] args) {

        //1、使用scanner,从键盘获取2023年的month、day
        Scanner scan = new Scanner(System.in); //阻塞式方法

        System.out.println("请输入2023年的月份");
        int month = scan.nextInt();

        System.out.println("请输入2023年的天:");
        int day = scan.nextInt();


        //2、使用switch-case 实现分支结构
        int sumDay = 0; //记录总天数

        //方式1,不推荐,冗余
/*        switch (month){
                case 1:
                    sumDay = day;
                    break;
                case 2:
                    sumDay = 31 + day;
                    break;
                case 3:
                    sumDay = 31 + 28 + day;
                    break;
                case 4:
                    sumDay = 31 + 28 + 31 + day;
                    break;
                case 5:
                    sumDay = 31 + 28 + 31 + 30 + day;
                    break;
                case 6:
                    sumDay = 31 + 28 + 31 + 30 + 31 + day;
                    break;
                case 7:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + day;
                    break;
                case 8:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + day;
                    break;
                case 9:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + 31 + day;
                    break;
                case 10:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + 31 + 30 + day;
                    break;
                case 11:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + 31 + 30 + 31 + day;
                    break;
                case 12:
                    sumDay = 31 + 28 + 31 + 30 + 31 +30 + 31 + 31 + 30 + 31 + 30 + day;
                    break;
            }*/

        //方式2
        switch (month){
            case 12:
                sumDay += 30;
            case 11:
                sumDay += 31;
            case 10:
                sumDay += 30;
            case 9:
                sumDay += 31;
            case 8:
                sumDay += 31;
            case 7:
                sumDay += 30;
            case 6:
                sumDay += 31;
            case 5:
                sumDay += 30;
            case 4:
                sumDay += 31;
            case 3:
                sumDay += 28;
            case 2:
                sumDay += 31;
            case 1:
                sumDay += day;
                break;
        }

            System.out.println("2023年" + month + "月" + day + "日,是当前的第" + sumDay + "天");

            scan.close(); //为了防止内存泄漏
    }
}




/*

import java.util.regex.Pattern;
import java.util.regex.Matcher;


//使用正则表达式进行日期校验
        public class DateValidator {

            private static final String DATE_PATTERN = "^(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])-(19|20)\\d\\d$";

            public static boolean isValidDate(String date) {
                Pattern pattern = Pattern.compile(DATE_PATTERN);
                Matcher matcher = pattern.matcher(date);
                return matcher.matches();
            }

            public static void main(String[] args) {
                String date = "2023-06-23";
                boolean isValid = isValidDate(date);
                System.out.println(" isValid: " + isValid);
            }
        }   */
2.2.4 练习

练习1
从键盘输入星期的整数值,输出星期的英文单词

import java.util.Scanner;

public class SwitchCaseExer1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);

        System.out.println("请输入星期值:");
        int weekday = input.nextInt();

        switch (weekday){
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("你输入的星期值有误!");
                break;
        }
        input.close();
    }
}

练习2
使用 switch 把小写类型的 char型转为大写。只转换 a, b, c, d, e. 其它的输出 “other”。

public class SwitchCaseExer2 {
    public static void main(String[] args) {
        char word = 'c';
        switch (word){
            case 'a':
                System.out.println('A');
                break;
            case 'b':
                System.out.println('B');
                break;
            case 'c':
                System.out.println('C');
                break;
            case 'd':
                System.out.println('D');
                break;
            case 'e':
                System.out.println('E');
                break;
             default:
                 System.out.println("other");
        }
    }
}

练习3

编写程序:从键盘上读入一个学生成绩,存放在变量score中,根据score的值输出其对应的成绩等级:

score>=90           等级:  A
70<=score<90        等级:  B    
60<=score<70        等级:  C
score<60            等级:  D

方式一:使用if-else
方式二:使用switch-case:  score / 10:   0 - 10
import java.util.Scanner;

public class SwitchCaseExer3 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入学生成绩:");

        int score = input.nextInt();
        char grade;//记录学生等级

/*        if (score >= 90){
            grade = 'A';
        }else if (score >= 70){
            grade = 'B';
        }else if (score >= 60){
            grade = 'C';
        }else {
            grade = 'D';
        }*/


//方式2:
        switch(score / 10){
            case 10:
            case 9:
                grade = 'A';
                break;
            case 8:
            case 7:
                grade = 'B';
                break;
            case 6:
                grade = 'C';
                break;
            default :
                grade = 'D';
        }

        System.out.println("学生成绩为" + score + ",对应的等级为" + grade);
        input.close();
    }
}

练习4
编写一个程序,为一个给定的年份找出其对应的中国生肖。中国的生肖基于12年一个周期,每年用一个动物代表:rat、ox、tiger、rabbit、dragon、snake、horse、sheep、monkey、rooster、dog、pig。

提示:2022年:虎 2022 % 12 == 6
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第48张图片

import java.util.Scanner;

/**
 * @author davina
 * @create 18:20
 */

public class SwitchCaseExer4 {
    public static void main(String[] args) {
        //从键盘输入一个年份
        Scanner input = new Scanner(System.in);
        System.out.println("请输入年份:");
        int year = input.nextInt();
        input.close();

        //判断
        switch (year % 12) {
            case 0:
                System.out.println(year + "是猴年");
                break;
            case 1:
                System.out.println(year + "是鸡年");
                break;
            case 2:
                System.out.println(year + "是狗年");
                break;
            case 3:
                System.out.println(year + "是猪年");
                break;
            case 4:
                System.out.println(year + "是鼠年");
                break;
            case 5:
                System.out.println(year + "是牛年");
                break;
            case 6:
                System.out.println(year + "是虎年");
                break;
            case 7:
                System.out.println(year + "是兔年");
                break;
            case 8:
                System.out.println(year + "是龙年");
                break;
            case 9:
                System.out.println(year + "是蛇年");
                break;
            case 10:
                System.out.println(year + "是马年");
                break;
            case 11:
                System.out.println(year + "是羊年");
                break;
            default:
                System.out.println(year + "输入错误");
        }
    }
}

练习5:押宝游戏
随机产生3个1-6的整数,如果三个数相等,那么称为“豹子”,如果三个数之和大于9,称为“大”,如果三个数之和小于等于9,称为“小”,用户从键盘输入押的是“豹子”、“大”、“小”,并判断是否猜对了

提示:随机数 Math.random()产生 [0,1)范围内的小数
如何获取[a,b]范围内的随机整数呢?(int)(Math.random() * (b - a + 1)) + a

import java.util.Scanner;

public class SwitchCaseExer5 {
    public static void main(String[] args) {
        //1、随机产生3个1-6的整数
        int a = (int)(Math.random()*6 + 1);
        int b = (int)(Math.random()*6 + 1);
        int c = (int)(Math.random()*6 + 1);

        //2、押宝
        Scanner input = new Scanner(System.in);
        System.out.print("请押宝(豹子、大、小):");
        String ya = input.next();
        input.close();

        //3、判断结果
        boolean result = false;
        //switch支持String类型
        switch (ya){
            case "豹子": result = a == b && b == c; break;
            case "大": result = a + b + c > 9; break;
            case "小": result = a + b + c <= 9; break;
            default:System.out.println("输入有误!");
        }

        System.out.println("a,b,c分别是:" + a +"," + b +"," + c );
        System.out.println(result ? "猜中了" : "猜错了");
    }
}
03、循环语句
  • 根据循环条件,重复性的执行某段代码。

  • 有for、while、do-while

  • 三种循环语句。

  • 补充:JDK5.0 提供了foreach循环,方便的遍历集合、数组元素。

  • 理解:循环语句具有在某些条件满足的情况下,反复执行特定代码的功能。

  • 循环结构分类:

    • for 循环
    • while 循环
    • do-while 循环
  • 循环结构四要素:

    • 初始化部分
    • 循环条件部分
    • 循环体部分
    • 迭代部分
3.1 for循环
3.1.1 基本语法

语法格式:
for (①初始化部分; ②循环条件部分; ④迭代部分){
③循环体部分;

执行过程:①-②-③-④-②-③-④-②-③-④-…-②
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第49张图片

3.1.2 应用举例

案例1:使用for循环重复执行某些语句
题目:输出5行HelloWorld

public class ForTest1 {
    public static void main(String[] args) {
/*        需求1:控制台输出5行Hello World!
        写法1:
        System.out.println("Hello World!");
        System.out.println("Hello World!");
        System.out.println("Hello World!");
        System.out.println("Hello World!");
        System.out.println("Hello World!");*/

        //写法2:
        for(int i = 1;i <= 5;i++){
            System.out.println("Hello World!");
        }
    }
}
public class ForTest2 {
	public static void main(String[] args) {
        int num = 1;
        for(System.out.print("a");num < 3;System.out.print("c"),num++){
            System.out.print("b");

        }
    }
}

案例2 累加
题目:遍历1-100以内的偶数,并获取偶数的个数,获取所有的偶数的和

public class ForTest3 {
	public static void main(String[] args) {
        int count = 0;//记录偶数的个数
        int sum = 0;//记录偶数的和

        for(int i = 1;i <= 100;i++){

            if(i % 2 == 0){
                System.out.println(i);
                count++;
                sum += i;
            }	
        }
        System.out.println("偶数的个数为:" + count);	
        System.out.println("偶数的总和为:" + sum);
    }
}

案例3:结合分支结构使用
题目:输出所有的水仙花数,所谓水仙花数是指一个3位数,其各个位上数字立方和等于其本身。例如: 153 = 111 + 333 + 555

public class ForTest4 {
	public static void main(String[] args) {
		//定义统计变量,初始化值是0
		int count = 0;
		
		//获取三位数,用for循环实现
		for(int x = 100; x < 1000; x++) {
			//获取三位数的个位,十位,百位
			int ge = x % 10;
			int shi = x / 10 % 10;
			int bai = x / 100;
			
			//判断这个三位数是否是水仙花数,如果是,统计变量++
			if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) {
                System.out.println("水仙花数:" + x);
				count++;
			}
		}
		
		//输出统计结果就可以了
		System.out.println("水仙花数共有"+count+"个");
	}
}

案例5: 结合break的使用
说明:输入两个正整数m和n,求其最大公约数和最小公倍数。
比如:12和20的最大公约数是4,最小公倍数是60。

import java.util.Scanner;

//输入两个正整数m和n,求其最大公约数和最小公倍数
public class ForTest1 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入正整数m: ");
        int m = input.nextInt();
        System.out.println("请输入正整数n: ");
        int n = input.nextInt();

        //获取m和n中的较小值
        int min = (m < n)? m : n;

        //需求1:最大公约数
        //方式1:
        int result = 1;
        for (int i = 1; i <= min; i++) {
            if (m % i == 0 && n % i == 0){
                //System.out.println(i);
                result = i;
            }
        }
        System.out.println(result);

        //方式2:推荐
        for (int i = min; i >= 1; i--) {
            if (m % i == 0 && n % i == 0) {
                System.out.println(i);
                break; //一旦执行就跳出当前循环
            }
        }


        //需求2:最小公倍数
        int max = (m > n)? m : n;
        for (int i = max; i <= m * n; i++) {
            if (i % m == 0 && i % n == 0 ){
                System.out.println(i);
                break;
            }
        }
    }
}

说明:

  • 1、我们可以在循环中使用break。一旦执行break,就跳出当前循环结构。
  • 2、小结:如何结束一个循环结构?
    • 结束情况1:循环结构中的循环条件部分返回false
    • 结束情况2:循环结构中执行了break。
  • 3、如果一个循环结构不能结束,那就是一个死循环!我们开发中要避免出现死循环
3.2 while循环
3.2.1 基本语法

语法格式:
①初始化部分
while(②循环条件部分){
③循环体部分;
④迭代部分;
}
执行过程:①-②-③-④-②-③-④-②-③-④-…-②

图示:
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第50张图片

说明:

  • while(循环条件)中循环条件必须是boolean类型。
  • 注意不要忘记声明④迭代部分。否则,循环将不能结束,变成死循环。
  • for循环和while循环可以相互转换。二者没有性能上的差别。实际开发中,根据具体结构的情况,选择哪个格式更合适、美观。
  • for循环与while循环的区别:初始化条件部分的作用域不同。
3.2.2 应用举例

需求1:遍历50次hello world
需求2:遍历1-100的偶数,并计算所有偶数的和、偶数的个数(累加的思想)

public class WhileTest {
    public static void main(String[] args) {

        //需求1:遍历50次hello world
        int i = 1;
        while (i <= 50){
            System.out.println("hello world!!");
            i++;
        }

        //需求2:遍历1-100的偶数,并计算所有偶数的和、偶数的个数(累加的思想)
        int j = 1;

        int count = 0;//记录偶数的个数
        int sum = 0; //记录偶数的总和

        while (j <= 100){
            if (j % 2 == 0){
                System.out.println(j);
                count++;
                sum += j;
            }
            j++;
        }
        System.out.println("偶数的个数为:" + count);
        System.out.println("偶数的总和为:" + sum);
    }
}

案例3:猜数字游戏
随机生成一个100以内的数,猜这个随机数是多少?

从键盘输入数,如果大了,提示大了;如果小了,提示小了;如果对了,就不再猜了,并统计一共猜了多少次。

提示:生成一个[a,b] 范围的随机数的方式:(int)(Math.random() * (b - a + 1) + a)

import java.util.Scanner;

public class WhileTest1 {
    public static void main(String[] args) {

        //1、生成一个[1,100]范围的随机整数
        int random = (int) (Math.random() * 100) + 1;

        //2、使用scanner,从键盘获取数据
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入1-100范围内的一个整数:");
        int guess = scan.nextInt();

        //3、声明一个变量,记录猜的次数
        int guessCount = 1;

        //3、使用循环结构,进行多次循环的对比和获取数据
        while (random != guess){

            if (guess > random){
                System.out.println("你输入的数据大了");
            }else if (guess < random){
                System.out.println("你输入的数据小了");
            }
            System.out.println("请输入1-100范围内的一个整数:");
            guess = scan.nextInt();
            guessCount++;
        }

        System.out.println("恭喜你!猜对了");
        System.out.println("共猜了" + guessCount + "次");
    }
}

案例4:折纸珠穆朗玛峰
世界最高山峰是珠穆朗玛峰,它的高度是8848.86米,假如我有一张足够大的纸,它的厚度是0.1毫米。
请问,我折叠多少次,可以折成珠穆朗玛峰的高度?

public class WhileTest2 {

    public static void main(String[] args) {

        //1、声明珠峰的高度,纸的默认厚度
        double paper = 0.1; //单位:毫米
        double zf = 8848860; //单位:毫米

        //2、定义一个变量,记录折纸的次数
        int count = 0;

        //3、通过循环结构,不断调整纸的厚度(当纸的厚度超过珠峰高度时,停止循环)
        while (paper <= zf){
            paper *= 2;
            count++;
        }
        System.out.println("paper的高度为:" + (paper / 1000) + ",超过了珠峰的高度" + (zf / 1000));
        System.out.println("共折纸" + count + "次");
    }
}
3.3 do-while循环
3.3.1 基本语法

语法格式:
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);
**执行过程:**①-③-④-②-③-④-②-③-④-…-②
图示:
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第51张图片

说明:

  • 结尾while(循环条件)中循环条件必须是boolean类型
  • do{}while();最后有一个分号
  • do-while结构的循环体语句是至少会执行一次,这个和for和while是不一样的
  • 循环的三个结构for、while、do-while三者是可以相互转换的。
3.3.2 应用举例

案例1
遍历1-100的偶数,并计算所有偶数的和、偶数的个数(累加的思想)

public class DoWhileTest {
    public static void main(String[] args) {

        //需求1:遍历1-100的偶数,并计算所有偶数的和、偶数的个数
        int i = 1;
        int count = 0;  //记录偶数的个数
        int sum = 0;    //记录偶数的总和
        do {
            if (i % 2 == 0){
                System.out.println(i);
                count++;
                sum += i;
            }
            i++;
        }while (i <= 100);
        System.out.println("偶数的个数为:" + count);
        System.out.println("偶数的总和为:" + sum);
    }
}

案例2:体会do-while至少会执行一次循环体

class DoWhileTest2 {
	public static void main(String[] args) {
        //while循环:
		int num1 = 10;
		while(num1 > 10){
			System.out.println("hello:while");
			num1--;
		}

		//do-while循环:
		int num2 = 10;
		do{
			System.out.println("hello:do-while");
			num2--;
		}while(num2 > 10);

	}
}

案例3:ATM取款
声明变量balance并初始化为0,用以表示银行账户的余额,下面通过ATM机程序实现存款,取款等功能。

=ATM
1、存款
2、取款
3、显示余额
4、退出
请选择(1-4):

import java.util.Scanner;

public class DoWhileTest1 {
    public static void main(String[] args) {
        //1、定义一个变量,记录银行账户余额
        double balance = 0.0;

        boolean flag = true; //控制循环的结束

        Scanner input = new Scanner(System.in); //实例化scanner

        do {
            //2、声明ATM收款界面
            System.out.println("=========ATM========");
            System.out.println("1、存款" );
            System.out.println("2、取款" );
            System.out.println("3、显示余额" );
            System.out.println("4、退出" );
            System.out.println("请选择(1-4):");

            //3、使用scanner获取用户的选择
            int selection = input.nextInt();

            switch (selection){
                //4、根据用户的选择,决定执行存款、取款、显示余额、退出的操作
                case 1:
                    System.out.println("请输入存款的金额:");
                    double money1 = input.nextDouble();
                    if (money1 > 0){
                        balance += money1;
                    }
                    break;
                case 2:
                    System.out.println("请输入取款的金额:");
                    double money2 = input.nextDouble();
                    if (money2 > 0 && money2 <= balance){
                        balance -= money2;
                    }else {
                        System.out.println("输入的数据有误或余额不足");
                    }
                    break;
                case 3:
                    System.out.println("显示金额为:" + balance);
                    break;
                case 4:
                    flag = false;
                    System.out.println("感谢使用,欢迎下次光临");
                    break;
                default:
                    System.out.println("输入有误,请重新输入");
            }
        }while (flag);

        //关闭资源
        input.close();
    }
}
3.4 对比三种循环结构

三种循环结构都具有四个要素:

  • 循环变量的初始化条件
  • 循环条件
  • 循环体语句块
  • 循环变量的修改的迭代表达式

从循环次数角度分析

  • do-while循环至少执行一次循环体语句。
  • for和while循环先判断循环条件语句是否成立,然后决定是否执行循环体。

如何选择

  • 遍历有明显的循环次数(范围)的需求,选择for循环
  • 遍历没有明显的循环次数(范围)的需求,选择while循环
  • 如果循环体语句块至少执行一次,可以考虑使用do-while循环
  • 本质上:三种循环之间完全可以互相转换,都能实现循环的功能
3.5 "无限"循环
3.5.1 基本语法

语法格式:

  • 最简单"无限"循环格式:while(true) , for(;
    适用场景:
  • 开发中,有时并不确定需要循环多少次,需要根据循环体内部某些条件,来控制循环的结束(使用break)。
  • 如果此循环结构不能终止,则构成了死循环!开发中要避免出现死循环。
3.5.2 应用举例

案例1:实现爱你到永远.

public class ForWhileTest {
    public static void main(String[] args) {
/*        while (true){
            System.out.println("I love you");
        }*/

        for (;;){
            System.out.println("I love you");
        }

        //死循环的后面不能有执行语句
        //System.out.println("end");
    }
}

案例2
从键盘读入个数不确定的整数,并判断读入的正数和负数的个数,输入为0时结束程序。

import java.util.Scanner;

public class ForWhileTest1 {
    public static void main(String[] args) {

        //从键盘读入个数不确定的整数,并判断读入的正数和负数的个数,输入为0时结束程序。
        int positiveCount = 0;  //记录正数的个数
        int negativeCount = 0;  //记录负数的个数
        Scanner input = new Scanner(System.in);

        while (true){
            System.out.println("请输入一个整数(输入为0时结束程序):");
            int num = input.nextInt(); //获取用户输入的整数

            if (num > 0){  //正数
                positiveCount++;
            }else if (num < 0){
                negativeCount++;
            }else {
                System.out.println("程序结束");
                break;
            }
        }
        System.out.println("正数的个数为:" + positiveCount);
        System.out.println("负数的个数为:" + negativeCount);
    }
}
3.6 嵌套循环(或多重循环)
3.6.1 使用说明

所谓嵌套循环:是指一个循环结构A的循环体是另一个循环结构B。比如,for循环里面还有一个for循环,就是嵌套循环。其中,for ,while ,do-while均可以作为外层循环或内层循环。

  • 外层循环:循环结构A
  • 内层循环:循环结构B

实质上,嵌套循环就是把内层循环当成外层循环的循环体。只有当内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的外层循环。
设外层循环次数为m次,内层为n次,则内层循环体实际上需要执行m*n次。

技巧:从二维图形的角度看,外层循环控制行数,内层循环控制列数。
开发经验:实际开发中,我们最多见到的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果将要出现,一定要停下来重新梳理业务逻辑,重新思考算法的实现,控制在三层以内。否则,可读性会很差。

3.6.2 应用举例

案例1:打印5行6个*



*******
*******
*******
*******
*******



public class ForForTest {
    public static void main(String[] args) {
        for (int j = 1;j <= 5;j++){
            for (int i = 0; i <= 6 ; i++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

案例2:打印5行直角三角形

*
**
***
****
*****

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

**案例3:**打印6行倒直角三角形

******
*****
****
***
**
*

public class ForForTest {
    public static void main(String[] args) {
        for (int j = 1;j <= 6;j++){
            for (int i = 1; i <= 7- j ; i++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

案例4:打印"菱形"形状的图案

        * 
      * * * 
    * * * * * 
  * * * * * * * 
* * * * * * * * * 
  * * * * * * * 
    * * * * * 
      * * * 
        * 

public class ForForTest {
    public static void main(String[] args) {
        //上半部分
        for (int i = 1; i <= 5; i++) {
            //空格
            for (int j = 1; j <= 10 -2*i ; j++) {
                System.out.print(" ");
            }
            //*
            for (int k = 1; k <= 2 * i -1 ; k++) {
                System.out.print("* ");
            }
            //换行
            System.out.println();
        }

        //下半部分
        for (int i = 1; i <= 4; i++) {
            //空格
            for (int j = 1; j <= 2 * i; j++) {
                System.out.print(" ");
            }

            //*
            for (int k = 1; k <= 9 - 2 * i; k++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

案例5:九九乘法表
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第52张图片

public class NineNineTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 9 ; i++) {
            for (int j = 1; j <= i ; j++) {
                System.out.print(i + "*" + j + "=" + (i * j) + "\t");
            }
            System.out.println();
        }
    }
}
3.6.3 练习

练习1:将一天中的时间打印到控制台

public class ForForTest1 {
    
    public static void main (String[] args) {
        for (int hour = 0;hour < 24 ;hour++ ) {
            for (int min = 0; min < 60 ; min++) {
                System.out.println(hour + "时" + min +"分"); 
            } 
        } 
    }
}
04、关键字break和continue的使用
4.1 break和continue的说明
适用范围 在循环结构中使用的作用 相同点
break switch-case 、循环结构 一旦执行,就结束(或跳出)当前循环结构 此关键字的后面,不能声明语句
continue 循环结构 一旦执行,就结束(或跳出)当次循环 此关键字的后面,不能声明语句

此外,很多语言都有goto语句,goto语句可以随意将控制转移到程序中的任意一条语句上,然后执行它,但使程序容易出错。Java中的break和continue是不同于goto的。

4.2 应用举例
public class NineNineTable {

    public static void main(String[] args) {

        for(int i = 1;i <= 10;i++){

            if(i % 4 == 0){
                //break;//123
                continue;//123567910
            }
            System.out.print(i);
        }

        System.out.println("####");

        //嵌套循环中的使用
        for(int i = 1;i <= 4;i++){

            for(int j = 1;j <= 10;j++){
                if(j % 4 == 0){
                    //break; //结束的是包裹break关键字的最近的一层循环!
                    continue;//结束的是包裹break关键字的最近的一层循环的当次!
                }
                System.out.print(j);
            }
            System.out.println();
        }
    }
}
4.3 带标签的使用

break语句用于终止某个语句块的执行
{ ……
break;
……
}

break语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块
label1: { ……
label2: { ……
label3: { ……
break label2;
……
}
}
}

  • continue语句出现在多层嵌套的循环语句体中时,也可以通过标签指明要跳过的是哪一层循环。
  • 标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
  • 举例:
class BreakContinueTest2 {
	public static void main(String[] args) {
		l:for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				if(j % 4 == 0){
					//break l;
					continue l;
				}
				System.out.print(j);
			}
			System.out.println();
		}
	}
}
4.4 经典案例

题目:找出100以内所有的素数(质数)?100000以内的呢?

public class PrimeNumberTest {
    public static void main(String[] args) {

        //方式一
       /* for (int i = 2; i <= 100 ; i++) { //遍历100以内自然数

            int number = 0; //记录i的约数的个数(从2开始)

            //判断i是否是质数
            for (int j = 2; j < i ; j++) {
                if (i % j == 0){
                    number++;
                }
            }

            if (number == 0){
                System.out.println(i);
            }
        }*/


       //方式二
        for (int i = 2; i <= 100 ; i++) { //遍历100以内自然数

            boolean isFlag = true;

            //判断i是否是质数
            for (int j = 2; j < i ; j++) {
                if (i % j == 0){
                    isFlag = false;
                }
            }

            if (isFlag){
                System.out.println(i);
            }
        }
    }
}

100000以内

public class PrimeNumberTest {
    public static void main(String[] args) {

       //获取系统当前时间
        long start = System.currentTimeMillis();  //总毫秒数  从1970年1月1日开始计算

        boolean isFlag = true;
        int count = 0; //记录质数的个数

        for (int i = 2; i <= 100000 ; i++) { //遍历100000以内自然数

            //判断i是否是质数
            for (int j = 2; j < i ; j++) {
                if (i % j == 0){
                    isFlag = false;
                }
            }

            if (isFlag){
                count++;
            }

            //重置isFlag
            isFlag = true;
        }

        //获取系统当前时间
        long end = System.currentTimeMillis();

        System.out.println("质数的总个数为:" + count);
        System.out.println("花费的时间为:" + (end - start));
    }
}

优化

public class PrimeNumberTest {
    public static void main(String[] args) {

        long start = System.currentTimeMillis(); //记录当前时间距离1970-1-1 00:00:00的毫秒数

        int count = 0;//记录质数的个数

        for(int i = 2;i <= 100000;i++){  //i

            boolean isFlag = true; //用于标识i是否被除尽过

            for(int j = 2;j <= Math.sqrt(i);j++){ //优化2:将循环条件中的i改为Math.sqrt(i)

                if(i % j == 0){ //表明i有约数
                    isFlag = false;
                    break;//优化1:主要针对非质数起作用
                }
            }

            //判断i是否是质数
            if(isFlag){ //如果isFlag变量没有给修改过值,就意味着i没有被j除尽过。则i是一个质数
                //System.out.println(i);
                count++;
            }
        }

        long end = System.currentTimeMillis();
        System.out.println("质数的个数为:" + count);
        System.out.println("执行此程序花费的毫秒数为:" + (end - start));//1062
    }
}
05、Scanner:键盘输入功能的实现
  • 如何从键盘获取不同类型(基本数据类型、String类型)的变量:使用Scanner类。
  • 键盘输入代码的四个步骤:
  • 1.导包:import java.util.Scanner;
  • 2.创建Scanner类型的对象:Scanner scan = new Scanner(System.in);
  • 3.调用Scanner类的相关方法(next() / nextXxx()),来获取指定类型的变量
  • 4.释放资源:scan.close();
  • 注意:需要根据相应的方法,来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时,会报异常 导致程序终止。
5.1 各种类型的数据输入

案例1:
小明注册某交友网站,要求录入个人相关信息。如下:
请输入你的网名、你的年龄、你的体重、你是否单身、你的性别等情况。

//步骤1、导包
import java.util.Scanner;

class ScannerTest {
    public static void main(String[] args) {

        //步骤2:创建Scanner的对象
        Scanner scan = new Scanner(System.in);

        System.out.println("欢迎来到交友网!");
        System.out.println("请输入你的网名: ");
        //步骤3:调用Scanner类中的方法,获取指定类型的变量
        String name = scan.next();

        System.out.println("请输入你的年龄: ");
        int age = scan.nextInt();

        System.out.println("请输入你的体重: ");
        double weight = scan.nextDouble();

        System.out.print("你是否单身(true/false):");
        boolean isSingle = scan.nextBoolean();

        System.out.print("请输入你的性别(男\\女):");
        char gender = scan.next().charAt(0);

        System.out.println("你的基本情况如下:");
        System.out.println("网名:" + name + "\n年龄:" + age + "\n体重:" + weight + "\n单身:" + isSingle + "\n性别:" + gender);
        System.out.println("注册完成,欢迎继续进入体验!");

        //步骤4:关闭资源,调用Scanner类的close()
        scan.close();

    }
}

案例2:

大家都知道,男大当婚,女大当嫁。那么女方家长要嫁女儿,当然要提出一定的条件:高:180cm以上;富:财富1千万以上;帅:是。

如果这三个条件同时满足,则:“我一定要嫁给他!!!”
如果三个条件有为真的情况,则:“嫁吧,比上不足,比下有余。”
如果三个条件都不满足,则:“不嫁!”

提示:
System.out.println(“身高: (cm));
scanner.nextInt();

System.out.println(“财富: (千万));
scanner.nextDouble();

System.out.println(“帅否: (true/false));   
scanner.nextBoolean();  

System.out.println(“帅否: (是/否));
scanner.next();   "是".equals(str) 
//步骤1、导包
import java.util.Scanner;

class ScannerExer1 {
    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);

        System.out.println("请输入你的身高:(cm)");
        int height = scan.nextInt();

        System.out.println("请输入你的财富:(以千万为单位)");
        double wealth = scan.nextDouble();

        //是否帅问题,使用String类型接收
        System.out.println("帅否?(是/否)");
        String isHandsome = scan.next();

        //判断
        if(height >= 180 && wealth >= 1.0 && isHandsome.equals("是")){  //知识点:判断两个字符串是否相等,使用String的equals()
            System.out.println("我一定要嫁给他!!!");
        }else if(height >= 180 || wealth >= 1.0 || isHandsome.equals("是")){
            System.out.println("嫁吧,比上不足,比下有余。");
        }else{
            System.out.println("不嫁");
        }

        //步骤4:关闭资源,调用Scanner类的close()
        scan.close();
    }
}
06、如何获取一个随机数

如何产生一个指定范围的随机整数?

  • 1、Math类的random()的调用,会返回一个[0,1)范围的一个double型值
  • 2、Math.random() * 100 —> [0,100) (int)(Math.random() * 100) —> [0,99] (int)(Math.random() * 100) + 5 ----> [5,104]
  • 3、如何获取[a,b]范围内的随机整数呢?(int)(Math.random() * (b - a + 1))+a
  • 4、举例
/*
如何产生一个随机数?

1、可以使用java提供的api:math类的random()
2、random()调用以后,会返回一个[0.0,1.0)范围的一个double型的随机数

3、需求1:获取 [0,100) 范围的随机整数
   需求2:获取 [1,100) 范围的随机整数
   
4、需求:获取[a,b] 范围的随机整数
 (int)Math.random() * (b - a + 1) + a    
*/


public class RandomTest {
    public static void main(String[] args) {

        double d1 = Math.random();
        System.out.println("d1 = " + d1);

        int d2 = (int)(Math.random() * 101) ;
        System.out.println("d2 = " + d2);

        int d3 = (int)(Math.random() * 100) +1 ;
        System.out.println("d3 = " + d3);
    }
}
07、谷粒记账软件项目

目标

  • 模拟实现一个基于文本界面的《谷粒记账软件》
  • 掌握初步的编程技巧和调试技巧
  • 主要涉及以下知识点
    • 变量的定义
    • 基本数据类型的使用
    • 循环语句
    • 分支语句
    • 方法声明、调用和返回值的接收
  • 简单的屏幕输出格式控制
    尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第53张图片
    尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第54张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第55张图片

Utility工具类

import java.util.Scanner;

/**
 * Utility工具类:
 * 将不同的功能封装为方法,就是可以直接通过调用方法使用它的功能,而无需考虑具体的功能实现细节
 */

public class Utility {
    private static Scanner scanner = new Scanner(System.in);
    /**
     * 用于界面菜单的选择。该方法读取键盘,如果用户键入 ‘1-4’中任意字符,则方法返回。返回值为用户键入字符
     */
    public static char readMenuSelection(){
        char c;
        for (; ; ){
            String str = readKeyBoard(1);
            c = str.charAt(0);
            if (c != '1' && c != '2'&& c != '3' && c != '4'){
                System.out.println("选择错误,请重新输入:");
            }
            else
                break;
        }
        return c;
    }

    /**
     * 用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数,并将其作为方法的返回值
     */
    public static int readNumber(){
        int n;
        for (; ; ){
            String str = readKeyBoard(4);
            try {
                n = Integer.parseInt(str);
                break;
            }catch (NumberFormatException e){
                System.out.println("数字输入错误,请重新输入:");
            }
        }
        return n;
    }
    /**
     * 用于收入和支出说明的输入。该方法从键盘读取一个不超过8位长度的字符串,并将其作为方法的返回值
     */
    public static String readString(){
        String str = readKeyBoard(8);
        return str;
    }

    /**
     * 用于确认选择的输入。该方法从键盘读取'Y'或'N',并将其作为方法的返回值
     */
    public static char readConfirmSelection(){
        char c;
        for (; ; ){
            String str = readKeyBoard(1).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N'){
                break;
            }else {
                System.out.println("选择错误,请重新输入:");
            }
        }
        return c;
    }

    private static String readKeyBoard(int limit){
        String line = "";

        while (scanner.hasNext()){
            line = scanner.nextLine();
            if (line.length() < 1 || line.length() > limit){
                System.out.println("输入长度(不大于" + limit + ")错误,请重新输入:");
                continue;
            }
            break;
        }
        return line;
    }
}

阶段一的项目:谷粒记账软件的实现


/**
 * 阶段一的项目:谷粒记账软件的实现
 */
public class GuLiAccont {
    public static void main(String[] args) {

        boolean isFlag = true; //控制循环结束

        //初始金额
        int balance = 10000;

        String info = ""; //记录收支的信息

        while (isFlag){
            System.out.println("------------------------------------谷粒记账软件------------------------------\n");
            System.out.println("                                     1、收支明细");
            System.out.println("                                     2、登记收入");
            System.out.println("                                     3、登记支出");
            System.out.println("                                     4、退    出\n");
            System.out.println("                                    请选择(1-4):");

            char selection = Utility.readMenuSelection();//获取用户的选项:'1'  '2' '3' '4'

            switch (selection){
                case '1':
                    System.out.println("----------------当前收支明细记录-------------");
                    System.out.println("收支\t账户余额\t收支金额\t说  明\n");
                    System.out.println(info);
                    System.out.println("---------------------------------------------");
                    break;
                case '2':
                    System.out.println("本次收入金额");
                    int money1 = Utility.readNumber();

                    if (money1 > 0){
                        balance += money1;
                    }

                    System.out.println("本次收入说明:");
                    String addDesc = Utility.readString();

                    info += "收入"+'\t' + balance + "\t" + "\t" + money1 + "\t" + "\t" + addDesc + "\n";

                    System.out.println("---------------------------登记完成---------------------------");
                    break;
                case '3':
                    System.out.println("本次支出金额");
                    int money2 = Utility.readNumber();

                    if (money2 > 0 && balance >= money2){
                        balance -= money2;
                    }

                    System.out.println("本次支出说明:");
                    String minusDesc = Utility.readString();

                    info += "支出" +"\t"+ balance + "\t" + "\t" + money2 + "\t" + "\t"+  "\t"  + minusDesc + "\n";

                    System.out.println("---------------------------登记完成---------------------------");
                    break;
                case '4':
                    System.out.println("\n确认是否退出(Y/N):");
                    char isExit = Utility.readConfirmSelection();
                    if (isExit == 'Y'){
                        isFlag = false;
                    }
                    break;
            }
        }
    }
}
08、企业中项目的研发流程

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第56张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第57张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第58张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第59张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第60张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第61张图片

在这里插入图片描述

四、idea的安装与使用

五、数组

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第62张图片

01. 数组的概述
1.1 为什么需要数组

需求分析1
需要统计某公司50个员工的工资情况,例如计算平均工资、找到最高工资等。用之前知识,首先需要声明50个变量来分别记录每位员工的工资,这样会很麻烦。因此我们可以将所有的数据全部存储到一个容器中统一管理,并使用容器进行计算。

容器的概念

  • 生活中的容器:水杯(装水等液体),衣柜(装衣服等物品),集装箱(装货物等)。
  • 程序中的容器:将多个数据存储到一起,每个数据称为该容器的元素。
1.2 数组的概念

数组(Array):是多个相同类型数据按一定顺序排列的集合,并使用一个名字命名,并通过编号的方式对这些数据进行统一管理。
数组中的概念

  • 数组名
  • 下标(或索引)
  • 元素
  • 数组的长度

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第63张图片

数组的特点

  • 数组本身是引用数据类型,而数组中的元素可以是任何数据类型,包括基本数据类型和引用数据类型。
  • 创建数组对象会在内存中开辟一整块连续的空间。占据的空间的大小,取决于数组的长度和数组中元素的类型。
  • 数组中的元素在内存中是依次紧密排列的,有序的。
  • 数组,一旦初始化完成,其长度就是确定的。数组的长度一旦确定,就不能修改。
  • 我们可以直接通过下标(或索引)的方式调用指定位置的元素,速度很快。
  • 数组名中引用的是这块连续空间的首地址。
1.3 数组的分类

1、按照元素类型分

  • 基本数据类型元素的数组:每个元素位置存储基本数据类型的值
  • 引用数据类型元素的数组:每个元素位置存储对象(本质是存储对象的首地址)(在面向对象部分讲解)
    2、按照维度分
  • 一维数组:存储一组数据
  • 二维数组:存储多组数据,相当于二维表,一行代表一组数据,只是这里的二维表每一行长度不要求一样。
    尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第64张图片
02. 一维数组的使用
2.1 一维数组的声明
public class OneArrayTest1 {
    public static void main(String[] args) {
        //1、数组的声明和初始化
        //复习:变量的定义格式: 数据类型 变量名 = 变量值
        int num1 = 10;
        int num2; //声明
        num2 = 20; //初始化

        //1.1声明数组
        double[] prices;
        //1.2数组的初始化
        //静态初始化:数组变量的赋值与数组元素的赋值操作同时进行
        prices = new double[]{20.23,32.98,75,48};

 /*       String[] foods;
        foods = new String[]{"拌海蜇","龙须菜","炝冬笋"};*/

        String[] foods;
        foods = new String[4];

        //数组的声明和初始化
        //动态初始化:数组变量的赋值与数组元素的赋值操作分开进行
        String[] foods2 = new String[3];

        //其他正确的方式
        int arr[]= new int[4];
        int[] arr1 = {1, 2, 3, 4}; //类型推断
        }
       } 
2.2 一维数组的初始化

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第65张图片

public class OneArrayTest1 {
    public static void main(String[] args) {
        //1、数组的声明和初始化
        //复习:变量的定义格式: 数据类型 变量名 = 变量值
        int num1 = 10;
        int num2; //声明
        num2 = 20; //初始化

        //1.1声明数组
        double[] prices;
        //1.2数组的初始化
        //静态初始化:数组变量的赋值与数组元素的赋值操作同时进行
        prices = new double[]{20.23,32.98,75,48};

 /*       String[] foods;
        foods = new String[]{"拌海蜇","龙须菜","炝冬笋"};*/

        String[] foods;
        foods = new String[4];

        //数组的声明和初始化
        //动态初始化:数组变量的赋值与数组元素的赋值操作分开进行
        String[] foods2 = new String[3];

        //其他正确的方式
        int arr[]= new int[4];
        int[] arr1 = {1, 2, 3, 4}; //类型推断


        //2、数组元素的调用
        //通过角标的方式,获取数组的元素
        //角标的范围[0,数组名.length - 1]
        System.out.println(prices[0]);
        System.out.println(prices[3]);

        foods[0] = "拌海蜇";
        foods[1] = "龙须菜";
        foods[2] = "炝冬笋";
        foods[3] = "酱茄子";


        //3、数组的长度:用来描述数组容器中容量的大小
        //使用length属性表示
        System.out.println(foods.length);
        System.out.println(prices.length);


        //4、如何遍历数组
/*        System.out.println(prices[0]);
        System.out.println(prices[1]);
        System.out.println(prices[2]);
        System.out.println(prices[3]);*/

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

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


        //5、数组元素的默认初始化值
        int[] arr2 = new int[5];
        System.out.println(arr2[0]);

        short[] arr3 = new short[4];
        for (int i = 0; i < arr3.length; i++) {
            System.out.println(arr3[i]);
        }

        double[] arr4 = new double[3];
        System.out.println(arr4[0]);

        char[] arr5 = new char[4];
        System.out.println(arr5[0]);

        if (arr5[0] == 0){
            System.out.println("111");
        }

        if (arr5[0] == '0'){
            System.out.println("222");
        }

        if (arr5[0] == '\u0000'){
            System.out.println("333");
        }

        System.out.println(arr5[0] + 1);


        boolean[] arr6 = new boolean[3];
        System.out.println(arr6[0]);

        String[] arr7 = new String[5];
        for (int i = 0; i < arr7.length; i++) {
            System.out.println(arr7[i]);
        }

        if (arr7[0] == null){
            System.out.println("aaaaaaaaa");
        }

        if (arr7[0] == "null"){
            System.out.println("bbbbbbbbb");
        }
    }
}
03. 一维数组内存分析
3.1、一个一维数组内存图

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第66张图片

public static void main(String[] args) {
  	int[] arr = new int[3];
  	System.out.println(arr);//[I@5f150435
}
3.2、两个一维数组内存图

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第67张图片

public static void main(String[] args) {
    int[] arr = new int[3];
    int[] arr2 = new int[2];
    System.out.println(arr);
    System.out.println(arr2);
}
3.3、两个变量指向一个一维数组

两个数组变量本质上代表同一个数组
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第68张图片

public static void main(String[] args) {
    // 定义数组,存储3个元素
    int[] arr = new int[3];
    //数组索引进行赋值
    arr[0] = 5;
    arr[1] = 6;
    arr[2] = 7;
    //输出3个索引上的元素值
    System.out.println(arr[0]);
    System.out.println(arr[1]);
    System.out.println(arr[2]);
    //定义数组变量arr2,将arr的地址赋值给arr2
    int[] arr2 = arr;
    arr2[1] = 9;
    System.out.println(arr[1]);
}
04. 一维数组的应用

案例1
升景坊单间短期出租4个月,550元/月(水电煤公摊,网费35元/月),空调、卫生间、厨房齐全。屋内均是IT行业人士,喜欢安静。所以要求来租者最好是同行或者刚毕业的年轻人,爱干净、安静。

public class ArrayExer {
    public static void main(String[] args) {
        int[] arr = new int[]{8, 2, 1, 0, 3, 6};
        int[] index = new int[]{2, 0, 4, 5, 1, 2, 3, 3, 1,2 ,4};

        String tel = "";

        for (int i = 0; i < index.length; i++) {
            int value = index[i];
            tel += arr[value];
        }
        System.out.println("联系方式:" + tel);
    }
}

案例2:输出英文星期几
用一个数组,保存星期一到星期天的7个英语单词,从键盘输入1-7,显示对应的单词

import java.util.Scanner;

public class ArrayExer02 {
    public static void main(String[] args) {
        //定义包含7个单词的数组
        String[] weeks = {"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};

        //从键盘获取指定的数值,使用scanner
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入数值(1-7):");
        int day = scan.nextInt();

        //针对获取的数据进行判断即可
        if (day < 1 || day > 7){
            System.out.println("您输入的数据有误");
        }else {
            System.out.println(weeks[day - 1]);
        }

        scan.close();
    }
}

案例3:从键盘读入学生成绩,找出最高分,并输出学生成绩等级。

  • 成绩>=最高分-10 等级为’A’
  • 成绩>=最高分-20 等级为’B’
  • 成绩>=最高分-30 等级为’C’
  • 其余 等级为’D’
    提示:先读入学生人数,根据人数创建int数组,存放学生成绩。
import java.util.Scanner;

public class ArrayExer03 {
    public static void main(String[] args) {
        //1、从键盘输入学生的人数,根据人数,创建数组(动态初始化)
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入学生人数:");
        int count = scan.nextInt();

        int[] scores = new int[count];

        //2、根据提示,依次输入学生成绩,并将成绩保存在数组元素中
        System.out.println("请输入这" + count + "个学生成绩");
        for (int i = 0; i < scores.length; i++) {
            scores[i] = scan.nextInt();
        }


        //3、获取学生成绩的最大值
        int maxScore = 0;
        //int maxScore1 = scores[0];
        for (int i = 0; i < scores.length; i++) {
            if (maxScore < scores[i]){
                maxScore = scores[i];
            }
        }

        System.out.println("最高分是:" + maxScore);

        //4、遍历数组元素,根据学生成绩与最高分的差值,得到每个学生的等级,并输出成绩和等级
        for (int i = 0; i < scores.length; i++) {
            if (scores[i] >= maxScore - 10){
                System.out.println("student " + (i+1) + " score is " + scores[i] + " grade is A");
            }else if (scores[i] >= maxScore - 20){
                System.out.println("student " + (i+1) + " score is " + scores[i] + " grade is B");
            }else if (scores[i] >= maxScore - 30){
                System.out.println("student " + (i+1) + " score is " + scores[i] + " grade is C");
            }else {
                System.out.println("student " + (i+1) + " score is " + scores[i] + " grade is D");
            }
        }
        scan.close();
    }
}
05. 多维数组的使用
5.1 概述

如果说可以把一维数组当成几何中的线性图形,那么二维数组就相当于是一个表格,像Excel中的表格、围棋棋盘一样。

  • 对于二维数组的理解,可以看成是一维数组array1又作为另一个一维数组array2的元素而存在
  • 其实,从数组底层的运行机制来看,其实没有多维数组
5.2 声明与初始化
public class TwoArrayTest {
    public static void main(String[] args) {
        //1、数组的声明和初始化
        //复习:
        int[] arr1 = new int[]{1,2,3};
        //方式1:静态初始化 :数组变量的赋值与数组元素的赋值操作同时进行
        int[][] arr2 = new int[][]{{1,2,3},{4,5},{6,7,8,9}};

        //方式2: 动态初始化1: 数组变量的赋值与数组元素的赋值操作分开进行
        String[][] arr3 = new String[3][4];

        //动态初始化2
        double[][] arr4 = new double[2][];

        //其他正确的方式
        int arr5[][]  = new int[][]{{1,2,3},{4,5},{6,7,8,9}};
        int [] arr6 []  = new int[][]{{1,2,3},{4,5},{6,7,8,9}};
        int arr7[][]  = {{1,2,3},{4,5},{6,7,8,9}};  //类型推断
        String arr8[][]  = new String[3][4];


        //2、数组元素的调用
        //针对arr2来说,外层元素{1,2,3},{4,5},{6,7,8,9}   内层元素 1,2,3,4,5,6,7,8,9
        //调用内层元素
        System.out.println(arr2[0][0]);   //1
        System.out.println(arr2[2][1]);   //7

        //调用外层元素
        System.out.println(arr2[0]);   //[I@4554617c  地址值

        //测试arr3,arr4
        arr3[0][1] = "Tom";
        System.out.println(arr3[0][1]);
        System.out.println(arr3[0]);

        arr4[0] = new double[4];
        arr4[0][0] = 1.0;

        //3、数组的长度
        System.out.println(arr2.length); //3
        System.out.println(arr2[0].length);  //3
        System.out.println(arr2[1].length); //2
        System.out.println(arr2[2].length); //4

        //4、如何遍历数组
        for (int i = 0; i < arr2.length; i++) {
            for (int j = 0; j < arr2[i].length; j++) {
                System.out.print(arr2[i][j] + "\t");
            }
            System.out.println();
        }

    }
}
5.3 二维数组的遍历
public class TwoArrayTest1 {
    public static void main(String[] args) {

        //5、数组元素的默认初始化值
        //以动态初始化方式1说明:
        int[][] arr1 = new int[3][2];

        //外层元素默认值
        System.out.println(arr1[0]);      //[I@4554617c
        System.out.println(arr1[1]);      // [I@74a14482
        //内层元素默认值
        System.out.println(arr1[0][0]);    // 0

        boolean[][] arr2 = new boolean[3][4];
        //外层元素默认值
        System.out.println(arr2[0]);      // [Z@1540e19d
        //内层元素默认值
        System.out.println(arr2[0][1]);  // false

        String[][] arr3 = new String[4][2];
        //外层元素默认值
        System.out.println(arr3[0]);      // [Ljava.lang.String;@677327b6
        //内层元素默认值
        System.out.println(arr3[0][1]);  // null


        //**********************************************************
        //以动态初始化方式2说明:
        int[][] arr4 = new int[4][];
        //外层元素默认值
        System.out.println(arr4[0]); // null
        //内层元素默认值
        System.out.println(arr4[0][0]);  //报错:空指针异常 Exception in thread “main” java.lang.NullPointerException


        String[][] arr5 = new String[5][];
        //外层元素默认值
        System.out.println(arr5[0]); // null
        //内层元素默认值
        System.out.println(arr5[0][0]); //报错
    }
}
5.4 内存解析

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第69张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第70张图片

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第71张图片

5.5 应用举例

案例1:获取arr数组中所有元素的和

public class ArrayExer01 {
    public static void main(String[] args) {

        //初始化数组:静态初始化
        int[][] arr = {{3, 5, 8}, {12, 9}, {7, 0, 6, 4}};

        int sum = 0; //记录元素的总和
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                sum += arr[i][j];
            }
        }
        System.out.println("总和为:" + sum);
    }
}
public class ArrayExer02 {
    public static void main(String[] args) {
        // = : 赋值符号
        int i = 10;
        int j = i;
        byte b = (byte)i;  //强制类型转换

        long l = i;  //自动类型提升


        //举例:数组
        int[] arr1 = new int[10];
        byte[] arr2 = new byte[20];
        //  arr1 = arr2 ; // 编译不通过,原因:int[]  byte[] 是两种不同类型的引用变量

        System.out.println(arr1);   //[I@4554617c
        System.out.println(arr2);  // [B@74a14482

        int[][] arr3 = new int[3][2];
        
        //  arr3 = arr1 ; // 编译不通过
        arr3[0] = arr1;
        System.out.println(arr3[0]);   //地址值类型相同
        System.out.println(arr1);
    }
}
public class ArrayExer02 {
    public static void main(String[] args) {
        String [][] employees = new String[][]{{"10","1","段誉","22","3000"},
                {"11","2","令狐冲","32","18000","15000","2000"},
                {"12","3","赵敏","23","7000"}
    };

        System.out.println("员工类型\t编号\t姓名\t年龄\t薪资\t奖金\t股票");

        for (int i = 0; i < employees.length; i++) {
            String employeeType  = employees[i][0];

            switch (employeeType){
                case "10":
                    System.out.print("普通员工\t");
                    break;
                case "11":
                    System.out.print("架构师\t\t");
                    break;
                case "12":
                    System.out.print("程序员\t\t");
                    break;
            }

            for (int j = 0; j < employees[i].length; j++) {
                System.out.print(employees[i][j] + "\t");
            }
            System.out.println();
        }
    }
}
06. 数组的常见算法
6.1 数值型数组特征值统计

这里的特征值涉及到:平均值、最大值、最小值、总和等

1、求最值

/**
 * 案例:定义一个int类型的一维数组,包含10个元素,分别赋一些随机整数,然后求出所有元素的最大值,最小值,总和,平均值,并输出出来
 *
 * 要求:所有随机数都是两位数,[10,99]
 *
 */

public class ArrayExer01 {
    public static void main(String[] args) {
        //1、动态初始化方式创建数组
        int[] arr = new int[10];
        //2、通过循环给数组元素赋值
        for (int i = 0; i < arr.length; i++) {
            arr[i] = (int)(Math.random() * (99 - 10 + 1)) + 10;
            System.out.print(arr[i] + "\t");
        }
        System.out.println();
        //3.1、求最大值
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]){
                max = arr[i];
            }
        }
        System.out.println("最大值为:" + max);
        //3.2、求最小值
        int min = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (min > arr[i]){
                min = arr[i];
            }
        }
        System.out.println("最大值为:" + min);
        //3.3、求总和
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总和为:" + sum);
        //3.4、求平均值
        int avgValue = sum / arr.length;
        System.out.println("平均值为:" + avgValue);
    }
}

2、评委打分

/**
 * 评委打分
 *
 * 在编程比赛中,10位评委打分: 5,4,6,8,9,8,1,2,7,3
 * 求最后得分,去掉一个最高分一个最低分
 *
 */

public class ArrayExer01 {
    public static void main(String[] args) {

        int[] scores = {5,4,6,8,9,8,1,2,7,3};
        //声明三个特征值
        int sum = 0;
        int max = 0;
        int min = 0;

        for (int i = 0; i < scores.length; i++) {
            sum += scores[i];  //累加总分
            //获取最高分
            if (max < scores[i]){
                max = scores[i];
            }
            //获取最低分
            if (min > scores[i]){
                min = scores[i];
            }
        }
        
        int avg = (sum - max - min) / (scores.length - 2);
        System.out.println("去掉一个最高分一个最低分之后,平均分为:" + avg);
    }
}

3、杨辉三角

/**
 * 杨辉三角
 *
 * 使用二维数组打印一个 10 行杨辉三角。
 * 提示:
 * 18.第一行有 1 个元素, 第 n 行有 n 个元素
 * 19.每一行的第一个元素和最后一个元素都是 1
 * 20.从第三行开始, 对于非第一个元素和最后一个元素的元素。即:
 *  yanghui[i][j] = yanghui[i-1][j-1] + yanghui[i-1][j];
 *
 */

public class ArrayExer01 {
    public static void main(String[] args) {

        //1、创建二维数组
        int[][] yanghui = new int[10][];

        //2、使用循环结构,初始化外层数组元素
        for (int i = 0; i < yanghui.length; i++) {
            yanghui[i] = new int[i + 1];
            //3、给数组的元素赋值
            //3.1、给数组每行的首末元素赋值为1
            yanghui[i][0] = yanghui[i][i] = 1;
            //3.2、给数组每行的非首末元素赋值
            for (int j = 1; j < yanghui[i].length - 1; j++) { //j从每行第二个元素开始,到倒数第2个元素结束
                yanghui[i][j] = yanghui[i - 1][j] + yanghui[i -1][j - 1];
            }
        }

        //遍历二维数组
        for (int i = 0; i < yanghui.length; i++) {
            for (int j = 0; j < yanghui[i].length; j++) {
                System.out.print(yanghui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

4、遍历扑克牌
遍历扑克牌,效果如图所示:
在这里插入图片描述

提示:使用两个字符串数组,分别保存花色和点数,再用一个字符串数组保存最后的扑克牌。
String[] hua = {“黑桃”,“红桃”,“梅花”,“方片”};
String[] dian = {“A”,“2”,“3”,“4”,“5”,“6”,“7”,“8”,“9”,“10”,“J”,“Q”,“K”};

public class ArrayExer01 {
    public static void main(String[] args) {

        String[] hua = {"黑桃","红桃","梅花","方片"};
        String[] dian = {"A","2","3","4","5","6","7","8","9","10","J","Q","K"};

        String[] pai = new String[hua.length * dian.length];
        int k = 0;
        for(int i = 0;i < hua.length;i++){
            for(int j = 0;j < dian.length;j++){
                pai[k++] = hua[i] + dian[j];
            }
        }

        for (int i = 0; i < pai.length; i++) {
            System.out.print(pai[i] + "  ");
            if (i % 13 == 12) {
                System.out.println();
            }
        }
    }
}

5、回形数
从键盘输入一个整数(1~20) ,则以该数字为矩阵的大小,把1,2,3…n*n 的数字按照顺时针螺旋的形式填入其中。
例如: 输入数字2,则程序输出:
1 2
4 3
输入数字3,则程序输出:
1 2 3
8 9 4
7 6 5

public class RectangleTest1 {

	public static void main(String[] args) {
		int n = 7;
		int[][] arr = new int[n][n];
		
		int count = 0; //要显示的数据
		int maxX = n-1; //x轴的最大下标
		int maxY = n-1; //Y轴的最大下标
		int minX = 0; //x轴的最小下标
		int minY = 0; //Y轴的最小下标
		while(minX<=maxX) {
			for(int x=minX;x<=maxX;x++) {
				arr[minY][x] = ++count;
			}
			minY++;
			for(int y=minY;y<=maxY;y++) {
				arr[y][maxX] = ++count;
			}
			maxX--;
			for(int x=maxX;x>=minX;x--) {
				arr[maxY][x] = ++count;
			}
			maxY--;
			for(int y=maxY;y>=minY;y--) {
				arr[y][minX] = ++count;
			}
			minX++;
		}
		
		
		for(int i=0;i<arr.length;i++) {
			for(int j=0;j<arr.length;j++) {
				String space = (arr[i][j]+"").length()==1 ? "0":"";
				System.out.print(space+arr[i][j]+" ");
			}
			System.out.println();
		}
	}
}
6.2 赋值、复制

使用简单数组
赋值

public class ArrayExer01 {
    public static void main(String[] args) {
        //(1)创建一个名为ArrayTest的类,在main()方法中声明array1和array2两个变量,他们是int[]类型的数组。
        int[] array1,array2;
        //(2)使用大括号{},把array1初始化为8个素数:2,3,5,7,11,13,17,19。
        array1 = new int[]{2,3,5,7,11,13,17,19};
        //(3)显示array1的内容。
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        //(4)赋值array2变量等于array1,修改array2中的偶索引元素,使其等于索引值(如array[0]=0,array[2]=2)。
        array2 = array1;

        for (int i = 0; i < array2.length; i++) {
            if (i % 2 == 0){
                array2[i] = i;
            }
        }

        System.out.println(); //换行
        System.out.println(array1);
        System.out.println(array2);

        // 打印出array1。
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
    }
}

思考:array1和array2是什么关系?
a:array1 和 array2 是两个变量,共同指向了堆空间中的同一个数组结构,即二者的地址值相同
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第72张图片

复制

public class ArrayExer01 {
    public static void main(String[] args) {
        //(1)创建一个名为ArrayTest的类,在main()方法中声明array1和array2两个变量,他们是int[]类型的数组。
        int[] array1,array2;
        //(2)使用大括号{},把array1初始化为8个素数:2,3,5,7,11,13,17,19。
        array1 = new int[]{2,3,5,7,11,13,17,19};
        //(3)显示array1的内容。
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
        //(4)复制array1数组给array2,修改array2中的偶索引元素,使其等于索引值(如array[0]=0,array[2]=2)。
        array2 = new int[array1.length];

        for (int i = 0; i < array1.length; i++) {
                array2[i] = array1[i];
        }

        System.out.println(); //换行
        System.out.println(array1);
        System.out.println(array2);

        for (int i = 0; i < array2.length; i++) {
            if (i % 2 == 0){
                array2[i] = i;
            }
        }

        // 打印出array1。
        for (int i = 0; i < array1.length; i++) {
            System.out.print(array1[i] + "\t");
        }
    }
}

尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第73张图片

6.3 数组元素的反转

实现思想:数组对称位置的元素互换
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第74张图片

案例:
定义数组: int[] arr = new int[]{23,55,78,45,84,95};
实现数组元素的反转存储

public class ArrayExer01 {
    public static void main(String[] args) {

        int[] arr = new int[]{23,55,78,45,84,95};

        //遍历
        for (int i = 0; i < arr.length ; i++) {
            System.out.print(arr[i] + "\t");
        }
        System.out.println();

        //反转操作
        //方式1:
/*        for (int i = 0; i < arr.length / 2; i++) {
            //交换 arr[i] 与 arr[arr.length - i - 1] 位置的元素
            int temp = arr[i];
            arr[i] = arr[arr.length  - 1 - i];
            arr[arr.length - 1 - i ] = temp;
        }*/

        //方式2:
        for (int i = 0 , j = arr.length -1; i < j ; i++,j--) {
            //交换 arr[i] 与 arr[j] 位置的元素
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }


/*        //方式3: 不推荐
        int[] newArr = new int[arr.length];
        for (int i = arr.length - 1; i >= 0 ; i--) {
            newArr[arr.length -1 -i] = arr[i];
        }*/

        arr = newArr;

        //遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}
6.4 数组的扩容与缩容

数组的扩容
题目:现有数组 int[] arr = new int[]{1,2,3,4,5}; ,现将数组长度扩容1倍,并将10,20,30三个数据添加到arr数组中

public class ArrayExer01 {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};

        //扩容1倍容量
        int[] newArr = new int[arr.length * 2];
        //或
        int[] newArr1 = new int[arr.length << 1];

        //将原有数组中的元素复制到新的数组中
        for (int i = 0; i < arr.length; i++) {

            newArr[i] = arr[i];
        }

        //将10,20,30三个数据添加到新的数组中
        newArr[arr.length] = 10;
        newArr[arr.length + 1] = 20;
        newArr[arr.length + 2] = 30;

        //将新的数组的地址赋值给原有的数组变量
        arr = newArr;
        
        //遍历arr
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}

数组的缩容
题目:现有数组 int[] arr={1,2,3,4,5,6,7}。现需删除数组中索引为4的元素。

public class ArrayExer01 {
    public static void main(String[] args) {
        int[] arr={1,2,3,4,5,6,7};

        int deleteIndex  = 4;

/*        //方式1:不新建数组
        for (int i = deleteIndex; i < arr.length -1; i++) {
            arr[i] = arr[i +1];
        }

        //修改最后元素,设置为默认值
        arr[arr.length -1] = 0;*/

        //方式2:新建数组,新的数组长度比原有数组的长度少一个
        int[] newArr = new int[arr.length -1];
        for (int i = 0; i < deleteIndex; i++) {
            newArr[i] = arr[i];
        }

        for (int i = deleteIndex; i < arr.length -1; i++) {
            newArr[i] = arr[i + 1];
        }

        arr = newArr;


        //遍历arr数组
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }
}
6.5 数组的元素查找
1、顺序查找

(线性查找)
优点:算法简单
缺点:效率低。执行的时间复杂度0(n)

定义数组:int[] arr = {4,5,6,1,34,12,15,9};
查找元素5是否存在,如果存在,输出对应的索引值

public class ArrayExer01 {
    public static void main(String[] args) {
        int[] arr = new int[]{4,6,1,17,34,2,5,12,15,9};

        int target = 5;

/*      //方式1:
        //查找方法:线性查找
        boolean isFlag = true;
        for (int i = 0; i < arr.length ; i++) {
            if (target == arr[i] ){
                System.out.println("找到了" + target + ",对应位置为:" + i);
                isFlag = false;
                break;
            }
        }

        if (isFlag){
            System.out.println("不好意思,没有找到此元素");
        }*/

        //方式2:
        int i = 0;
        for (; i < arr.length; i++) {
            if (target == arr[i]){
                System.out.println("找到了" + target + ",对应位置为:" + i);
                break;
            }
        }

        if (i == arr.length){
            System.out.println("不好意思,没有找到此元素");
        }
    }
}
2、二分查找

优点:执行效率高
缺点:算法相对于顺序查找难一点,前提,数组必须有序

实现步骤:
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第75张图片
举例
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第76张图片

定义数组:int[] arr = {4,5,6,25,34,12,15,9};
查找元素5是否存在,如果存在,输出对应的索引值

public class ArrayExer01 {
    public static void main(String[] args) {
        int[] arr = {4,5,6,1,25,34,12,15,9};

        int target = 5;

        int head = 0; //默认的首索引
        int end = arr.length -1; //默认的尾索引

        boolean isFlag = true; //判断是否找到了指定元素

        while (head <= end){

            int middle = (head + end) / 2;

            if (target == arr[middle]){
                System.out.println("找到了" + target + ",对应的位置为:" + middle);
                isFlag = false;
                break;
            }else if (target > arr[middle]){
                head = middle + 1;
            }else { //target < arr[middle]
                end = middle - 1;
            }
        }

        if (isFlag){
            System.out.println("不好意思,没有找到");
        }
    }
}

第二阶段:Java面向对象编程

六、面向对象编程(基础)

本章专题与脉络
尚硅谷Java零基础全套视频教程(宋红康2023版,java入门自学必备)_第77张图片

01、面向对象编程概述(了解)
1.1 面向对象与面向过程的区别

学习面向对象内容的三条主线

  • Java类及类的成员:(重点)属性、方法、构造器;(熟悉)代码块、内部类
  • 面向对象的特征:封装、继承、多态、(抽象)
  • 其他关键字的使用:this、super、package、import、static、final、interface、abstract等

1、面向过程的程序设计思想(Process-Oriented Programming),简称POP

  • 关注的焦点是过程:过程就是操作数据的步骤。如果某个过程的实现代码重复出现,那么就可以把这个过程抽取为一个函数。这样就可以大大简化冗余代码,便于维护。
  • 典型的语言:C语言
  • 代码结构:以函数为组织单位。
  • 是一种“执行者思维”,适合解决简单问题。扩展能力差、后期维护难度较大。

2、 面向对象的程序设计思想( Object Oriented Programming),简称OOP

  • 关注的焦点是:在计算机程序设计过程中,参照现实中事物,将事物的属性特征、行为特征抽象出来,用类来表示。
  • 典型的语言:Java、C#、C++、Python、Ruby和PHP等
  • 代码结构:以为组织单位。每种事物都具备自己的属性行为/功能
  • 是一种“设计者思维”,适合解决复杂问题。代码扩展性强、可维护性高。
1.2 二者的关系

我们千万不要把面向过程和面向对象对立起来。他们是相辅相成的。面向对象离不开面向过程

02、面向对象的两个核心概念:类(Class)和对象(Object)
  • :具有相同特征的事物的抽象描述,是抽象的、概念上的定义。
  • 对象:实际存在的该类事物的每个个体,是具体的,因而也称为实例(instance)。

类 => 抽象概念的人;对象 => 实实在在的某个人

2.1 类的成员概述
  • 面向对象程序设计的重点是类的设计
  • 类的设计,其实就是类的成员的设计
  • Java代码世界是由诸多个不同功能的类构成的。

Java中用类class来描述事物也是如此。类,是一组相关属性和行为的集合,这也是类最基本的两个成员。
属性:该类事物的状态信息。对应类中的成员变量

  • 成员变量 <=> 属性 <=> Field
    行为:该类事物要做什么操作,或者基于事物的状态能做什么。对应类中的成员方法
  • (成员)方法 <=> 函数 <=> Method

七、面向对象编程(进阶)

八、面向对象编程(高级)

第三阶段:Java高级应用

九、异常处理

十、多线程

十一、常用类和基础API

十二、集合框架

十三、泛型

十四、数据结构与集合源码

十五、file类与IO流

十六、网络编程

十七、反射机制

十八、JDK8-17新特性

你可能感兴趣的:(java,开发语言)