有经验的企业做网站,网站建设要求有哪些,佛山市建设工程交易中心,做个游戏app的费用大概多少尚硅谷Java零基础全套视频教程(宋红康2023版#xff0c;java入门自学必备)
开发环境#xff1a;jdk17 idea2022
第一阶段#xff1a;Java基本语法
一、Java语言概述
01、Java新版视频教程简介 02、课程目录说明 03、Java基础全栈学习路线
04、抽茧剥丝话Java 05、Java…尚硅谷Java零基础全套视频教程(宋红康2023版java入门自学必备)
开发环境jdk17 idea2022
第一阶段Java基本语法
一、Java语言概述
01、Java新版视频教程简介 02、课程目录说明 03、Java基础全栈学习路线
04、抽茧剥丝话Java 05、Java工程师全程学习路线 06、计算机硬件的介绍
6.1 计算机组成硬件软件 6.2 CPU、内存与硬盘 6.3 输入设备键盘输入
金山打字通
07、常见的DOS命令
DOSDisk Operating System磁盘操作系统是Microsoft公司在Windows之前推出的一个操作系统是单用户、单任务即只能执行一个任务的操作系统。现在被Windows系统取代。
进入DOS操作窗口 按下WindowsR键盘打开运行窗口输入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、PythonScala等。
8.2 计算机语言简史 高级语言独立于机器有一定的通用性计算机不能直接识别和执行用高级语言编写的程序需要使用编译器或者解释器转换为机器语言才能被识别和执行 高级语言按照程序设计方法的不同又分为面向过程的语言、面向对象的语言。
1.C、Pascal、Fortran面向过程的语言2.C面向过程/面向对象3.Java跨平台的纯面向对象的语言4.C#、Python、JavaScript、Scala…
8.3 计算机语言排行榜
TIOBE https://www.tiobe.com/tiobe-index/流行编程语言排行每月更新
网传的编程语言鄙视链
09、Java相关历史
10、JDK的选择和下载
path 路径从上往下识别
11、 HelloWorld
11.1 开发步骤
Java程序开发三步骤编写、编译、运行。
将 Java 代码编写到扩展名为 .java 的源文件中通过 javac.exe 命令对该 java 文件进行编译生成一个或多个字节码文件通过 java.exe 命令对生成的 class 文件进行运行
HelloWorld
cmd 复制路径 右击粘贴新建文件后缀为 .java 内容 编码格式 – ANSI
// 类 类名{}
class HelloChina{}cmd
C:\Users\stue:E:\cd E:\z_teach\javacode\chapter01E:\z_teach\javacode\chapter01javac HelloWorld.java
结果 cmd
E:\z_teach\javacode\chapter01java 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\chapter01javac HelloWorld.javaE:\z_teach\javacode\chapter01java HelloChinaE:\z_teach\javacode\chapter01内容
class HelloChina{public static void main(String[] args){System.out.println(hello,world!!);System.out.println(你好,中国!!);}
}重新运行
E:\z_teach\javacode\chapter01javac HelloWorld.javaE:\z_teach\javacode\chapter01java 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\chapter01javac HelloWorld.java结果
12.、HelloWorld总结 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\chapter01javadoc -d mydoc -author -version CommentTest.java结果 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 优点
跨平台性
面向对象性 面向对象编程支持封装、继承、多态等特性让程序更好达到高内聚低耦合的标准。 健壮性 吸收了C/C语言的优点但去掉了其影响程序健壮性的部分如指针、内存的申请与释放等提供了一个相对安全的内存管理和访问机制
15.1.2 缺点
语法过于复杂、严谨对程序员的约束比较多与python、php等相比入门较难。但是一旦学会了就业岗位需求量大而且薪资待遇节节攀升。一般适用于大型网站开发整个架构会比较重对于初创公司开发和维护人员的成本比较高即薪资高选择用Java语言开发网站或应用系统的需要一定的经济实力。并非适用于所有领域
15.2 JVM功能说明 JVMJava 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\chapter01javac PersonalInfo.javaE:\z_teach\javacode\chapter01java PersonalInfo
姓名康师傅性别男
家庭住址北京程序员聚集地回龙观E:\z_teach\javacode\chapter01案例2输出心形
结合\n(换行)\t(制表符)空格等在控制台打印出如下图所示的效果。 方式一 //方式一
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\tI 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核心技术》、《effective java》、《java编程思想》
17.1.2、软件开发相关内容 没有最好的语言只有在特地场景下相对来说最适合的语言
17.1.3、java概述 17.1.4、Java环境的搭建 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是一门半编译半解释型的语言
二、变量与运算符
01、关键字、保留字
定义被Java语言赋予了特殊含义用做专门用途的字符串或单词HelloWorld案例中出现的关键字有 class、public 、 static 、 void 等这些单词已经被Java定义好了。
特点全部关键字都是小写字母。 关键字比较多不需要死记硬背学到哪里记到哪里即可。
官方地址
说明 1.关键字一共50个其中const和goto是保留字(reserved word)。 2.truefalsenull不是关键字是字面量表示特殊的布尔值和空值可以当做关键字来看待
保留字 const、goto
02. 标识符( identifier)
凡是自己可以起名字的地方都叫标识符。比如类名、变量名、方法名、接口名、包名、常量名
2.1、标识符的命名规则必须遵守的硬性规定
由26个英文字母大小写0-9 _或 $ 组成数字不可以开头。不可以使用关键字和保留字但能包含关键字和保留字。Java中严格区分大小写长度无限制。标识符不能包含空格。
2.2、标识符的命名规范 包名多单词组成时所有字母都小写xxxyyyzzz。 例如java.lang、com.atguigu.bean 类名、接口名多单词组成时所有单词的首字母大写XxxYyyZzz 例如HelloWorldStringSystem等 变量名、方法名多单词组成时第一个单词首字母小写第二个单词开始每个单词首字母大写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){//定义变量的方式1char 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中变量的数据类型分为两大类
基本数据类型包括 整数类型、浮点数类型、字符类型、布尔类型。引用数据类型包括数组、 类、接口、枚举、注解、记录。 3.4、变量的使用 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’或Llong l1 123123123L; //②开发中定义整型变量时无特殊情况通常声明为int类型//2、测试浮点型变量的使用// float \ doubledouble d1 12.3;//①声明float类型变量时需要提供后缀后缀为‘f’或Ffloat f1 12.3f;System.out.println(f1 f1);//②开发中定义浮点型变量时无特殊情况通常声明为double类型,因为精度更高//③ float 类型表数范围大于long类型的但是精度不高//测试浮点型变量的精度//浮点型变量的精度不高需要精确数字计算或保留指定位数的精度需要使用BigDecimal类。//测试1System.out.println(0.1 0.2);//测试2float 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.8public 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){ // 布尔类型booleanboolean 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;//特殊情况1byte,short之间运算byte b3 12;short s1 10;//编译不通过//short s2 b3 s1;i3 b3 s1;byte b4 10;int i4 b3 b4;//特殊情况2charchar c1 a;//编译不通过//char c2 c1 b3;int i5 c1 b3;//**************************************//练习1long l2 123L;long l3 123; //理解为自动类型提升//long l4 123123123123; //123123123123理解为int类型因为超出了int范围所以报错long l5 123123123123L; //此时的123123123123L就是使用8个字节存储的long类型的值//练习2float 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.0float f2 (float)i3; //编译可以通过省略()而已//精度损失的例子1double d2 12.9;int i4 (int)d2;System.out.println(i4);//精度损失的例子2int 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); //hellotrueString 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、进制的认识 二进制binary以0B、0b开头、十进制、八进制以0开头、十六进制以0x、0X开头的声明方式二进制的理解正数原码、反码、补码三码合一负数原码、反码、补码不相同。计算机的底层是以补码的方式存储数据的熟悉二进制与十进制之间的转换了解二进制与八进制、十六进制之间的转换
07、运算符Operator重点
7.1 算术运算符 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再运算//(后)先运算再自增1int a1 10;int b1 a1; System.out.println(a1 a1 , b1 b1); // a1 11,b1 11int a2 10;int b2 a2; System.out.println(a2 a2 , b2 b2); // a2 11,b2 10//练习1int i 10;// i;i;System.out.println(i i); // 11//练习2short 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); //2int k 2;
int z k;
System.out.println(z); //3int m 2;
m m;
System.out.println(m); //27.2 赋值运算符
7.2.1 基本语法 、、 -、*、 /、%
/*
当“”两侧数据类型不一致时可以使用自动类型转换或使用强制类型转换原则进行处理。*/ class SetValueTest {public static void main(String[] args){int i 5;long l 10; // 自动类型提升byte b (byte)i; //强制类型转换//操作方式1int 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 //方式1int n1 10;n1 n1 2;//方式2(推荐int n2 10;n2 2;//练习2如何实现一个变量的值增加1 //方式1int i1 10;i1 i1 1;//方式2int i2 10;i2 1;//方式3(推荐int i3 10;i3; // i3;}
} 7.3 比较(关系)运算符 •比较运算符的结果都是boolean型也就是要么是true要么是false。 • 只适用于基本数据类型除boolean类型之外 ! 适用于基本数据类型和引用数据类型 •比较运算符“”不能误写成“”
class CompareTest {public static void main(String[] args) {int i1 10;int i2 20;System.out.println(i1 i2);//falseSystem.out.println(i1 ! i2);//trueSystem.out.println(i1 i2);//falseint m 10;int n 20;System.out.println(m n);//falseSystem.out.println(m n);//20boolean b1 false;boolean b2 true;System.out.println(b1 b2);//falseSystem.out.println(b1 b2);//true}
}7.4 逻辑运算符 逻辑运算符操作的都是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. 定义类 LogicExer2. 定义 main方法3. 定义一个int类型变量a,变量b,都赋值为204. 定义boolean类型变量bo1 , 判断a 是否被3整除,并且a 是否被7整除,将结果赋值给bo15. 输出a的值,bo1的值6. 定义boolean类型变量bo2 , 判断b 是否被3整除,并且b 是否被7整除,将结果赋值给bo27. 输出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 位运算符 /*
位运算符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 : 14System.out.println(num1 2 : (num1 2)); // num1 2 : 28System.out.println(num1 3 : (num1 3)); // num1 3 : 56System.out.println(num1 28 : (num1 28)); //num1 28 : 1879048192System.out.println(num1 29 : (num1 29)); //num1 29 : -536870912 过犹不及int num2 -7;System.out.println(num2 1 : (num2 1)); //num2 1 : -14System.out.println(num2 2 : (num2 2)); // num2 2 : -28System.out.println(num2 3 : (num2 3)); // num2 3 : -56//面试题高效计算 2 * 8// 2 3 或 8 1//694 类似于 69/2的4次 69/16 4System.out.println(69 4); //4System.out.println(62 3); //7System.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) ^ nm 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);}
}/*练习今天是周210天以后是周几*/
class ConditionExer{public static void main(String[] args) {int week 2;week 10;week % 7;System.out.println(今天是周210天以后是周 ((week 0)? 日 : week) );}
}7.6.3 与if-else的转换关系
凡是可以使用条件运算符的地方都可以改写为if-else结构。反之不成立
开发中如果既可以使用条件运算符又可以使用if-else推荐使用条件运算符。因为执行效率稍高
7.7 运算符优先级
运算符有不同的优先级所谓优先级就是在表达式运算中的运算符顺序。 上一行中的运算符总是优先于下一行的。
优先级运算符说明Java运算符1括号()、[]、{}2正负号、-3单元运算符、–、~、4乘法、除法、求余*、/、%5加法、减法、-6移位运算符、、7关系运算符、、、、instanceof8等价运算符、!9按位与10按位异或^11按位或”12条件与13条件或”14三元运算符? :15赋值运算符、、-、*、/、%16位赋值运算符、
开发建议 1.不要过多的依赖运算的优先级来控制表达式的执行顺序这样可读性太差尽量使用()来控制表达式的执行顺序。 2.不要把一个表达式写得过于复杂如果一个表达式过于复杂则把它分成几步来完成。例如 (num1 num2) * 2 num3 num2 num3 ? num3 : num1 num2;
三、流程控制语句 01、顺序结构
程序从上到下逐行地执行中间没有任何判断和跳转 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(条件表达式)语句块;说明条件表达式必须是布尔表达式关系表达式或逻辑表达式或 布尔变量。 结构2双分支条件判断if…else 格式
if(条件表达式) { 语句块1;
}else {语句块2;
}结构3多分支条件判断if…else if…else 格式
if (条件表达式1) {语句块1;
} else if (条件表达式2) {语句块2;
}
...
}else if (条件表达式n) {语句块n;
} else {语句块n1;
}说明一旦条件表达式为true则进入执行相应的语句块。执行完对应的语句块之后就跳出当前结构
当条件表达式之间是“互斥”关系时即彼此没有交集条件判断语句及执行语句间顺序无所谓。 当条件表达式之间是“包含”关系时“小上大下 / 子上父下”否则范围小的条件表达式将不可能被执行。
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分时奖励一辆跑车 成绩为(8099]时奖励一辆山地自行车 当成绩为[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);
} elseSystem.out.println(x is x);练习2
boolean b true;
//如果写成if(bfalse)能编译通过吗如果能结果是
if(b false) //建议if(!b)System.out.println(a);
else if(b)System.out.println(b);
else if(!b)System.out.println(c);
elseSystem.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:执行语句n1;break;]
}执行流程图 执行过程
第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(表达式)中表达式的值必须是下述几种类型之一byteshortcharint枚举 (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、dayScanner 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;}*///方式2switch (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的值输出其对应的成绩等级score90 等级: A
70score90 等级: B
60score70 等级: C
score60 等级: D方式一使用if-else
方式二使用switch-case: score / 10: 0 - 10import 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;}*///方式2switch(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
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 (①初始化部分; ②循环条件部分; ④迭代部分) ③循环体部分; 执行过程①-②-③-④-②-③-④-②-③-④-…-②
3.1.2 应用举例
案例1使用for循环重复执行某些语句 题目输出5行HelloWorld
public class ForTest1 {public static void main(String[] args) {
/* 需求1控制台输出5行Hello World!写法1System.out.println(Hello World!);System.out.println(Hello World!);System.out.println(Hello World!);System.out.println(Hello World!);System.out.println(Hello World!);*///写法2for(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) {//定义统计变量初始化值是0int 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*geshi*shi*shibai*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最大公约数//方式1int 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(②循环条件部分) ③循环体部分; ④迭代部分; } 执行过程①-②-③-④-②-③-④-②-③-④-…-②
图示
说明
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 worldint 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(②循环条件部分); **执行过程**①-③-④-②-③-④-②-③-④-…-② 图示
说明
结尾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);}
}案例3ATM取款 声明变量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); //实例化scannerdo {//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九九乘法表
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;//123continue;//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;}//重置isFlagisFlag 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){ //iboolean 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))a4、举例
/*
如何产生一个随机数1、可以使用java提供的apimath类的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、谷粒记账软件项目
目标
模拟实现一个基于文本界面的《谷粒记账软件》掌握初步的编程技巧和调试技巧主要涉及以下知识点 变量的定义基本数据类型的使用循环语句分支语句方法声明、调用和返回值的接收 简单的屏幕输出格式控制 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(选择错误请重新输入);}elsebreak;}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 4switch (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、企业中项目的研发流程 四、idea的安装与使用
五、数组 01. 数组的概述
1.1 为什么需要数组
需求分析1 需要统计某公司50个员工的工资情况例如计算平均工资、找到最高工资等。用之前知识首先需要声明50个变量来分别记录每位员工的工资这样会很麻烦。因此我们可以将所有的数据全部存储到一个容器中统一管理并使用容器进行计算。
容器的概念
生活中的容器水杯装水等液体衣柜装衣服等物品集装箱装货物等。程序中的容器将多个数据存储到一起每个数据称为该容器的元素。
1.2 数组的概念
数组(Array)是多个相同类型数据按一定顺序排列的集合并使用一个名字命名并通过编号的方式对这些数据进行统一管理。 数组中的概念
数组名下标或索引元素数组的长度 数组的特点
数组本身是引用数据类型而数组中的元素可以是任何数据类型包括基本数据类型和引用数据类型。创建数组对象会在内存中开辟一整块连续的空间。占据的空间的大小取决于数组的长度和数组中元素的类型。数组中的元素在内存中是依次紧密排列的有序的。数组一旦初始化完成其长度就是确定的。数组的长度一旦确定就不能修改。我们可以直接通过下标(或索引)的方式调用指定位置的元素速度很快。数组名中引用的是这块连续空间的首地址。
1.3 数组的分类
1、按照元素类型分
基本数据类型元素的数组每个元素位置存储基本数据类型的值引用数据类型元素的数组每个元素位置存储对象本质是存储对象的首地址在面向对象部分讲解 2、按照维度分一维数组存储一组数据二维数组存储多组数据相当于二维表一行代表一组数据只是这里的二维表每一行长度不要求一样。
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 一维数组的初始化 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、一个一维数组内存图 public static void main(String[] args) {int[] arr new int[3];System.out.println(arr);//[I5f150435
}3.2、两个一维数组内存图 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、两个变量指向一个一维数组
两个数组变量本质上代表同一个数组
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的地址赋值给arr2int[] 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};//从键盘获取指定的数值使用scannerScanner 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 (i1) score is scores[i] grade is A);}else if (scores[i] maxScore - 20){System.out.println(student (i1) score is scores[i] grade is B);}else if (scores[i] maxScore - 30){System.out.println(student (i1) score is scores[i] grade is C);}else {System.out.println(student (i1) 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];//动态初始化2double[][] 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]); //1System.out.println(arr2[2][1]); //7//调用外层元素System.out.println(arr2[0]); //[I4554617c 地址值//测试arr3,arr4arr3[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); //3System.out.println(arr2[0].length); //3System.out.println(arr2[1].length); //2System.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]); //[I4554617cSystem.out.println(arr1[1]); // [I74a14482//内层元素默认值System.out.println(arr1[0][0]); // 0boolean[][] arr2 new boolean[3][4];//外层元素默认值System.out.println(arr2[0]); // [Z1540e19d//内层元素默认值System.out.println(arr2[0][1]); // falseString[][] 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.NullPointerExceptionString[][] arr5 new String[5][];//外层元素默认值System.out.println(arr5[0]); // null//内层元素默认值System.out.println(arr5[0][0]); //报错}
}5.4 内存解析 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); //[I4554617cSystem.out.println(arr2); // [B74a14482int[][] 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、给数组每行的首末元素赋值为1yanghui[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(minXmaxX) {for(int xminX;xmaxX;x) {arr[minY][x] count;}minY;for(int yminY;ymaxY;y) {arr[y][maxX] count;}maxX--;for(int xmaxX;xminX;x--) {arr[maxY][x] count;}maxY--;for(int ymaxY;yminY;y--) {arr[y][minX] count;}minX;}for(int i0;iarr.length;i) {for(int j0;jarr.length;j) {String space (arr[i][j]).length()1 ? 0:;System.out.print(spacearr[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是什么关系 aarray1 和 array2 是两个变量共同指向了堆空间中的同一个数组结构即二者的地址值相同
复制
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);}}
}6.3 数组元素的反转
实现思想数组对称位置的元素互换
案例 定义数组 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;}*///方式2for (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;//遍历arrfor (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、顺序查找
线性查找 优点算法简单 缺点效率低。执行的时间复杂度0n
定义数组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(不好意思没有找到此元素);}*///方式2int 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、二分查找
优点执行效率高 缺点算法相对于顺序查找难一点前提数组必须有序
实现步骤 举例
定义数组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面向对象编程
六、面向对象编程基础
本章专题与脉络
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新特性
