java入门上部
人机交互
CMD
**CMD:**在windows中，利用命令行的方式操作计算机。可以打开文件，打开文件夹，创建文件夹等等
打开CMD
打开步骤：
1、Win + R, 出现运行窗口
2、在运行窗口输入 CMD, 应输入小写 cmd
3、 然后按 Enter(回车)， 在C:\Users\287557> 后输入CMD的常见命令
常见CMD命令
-
盘符名称 + 冒号
说明：盘符切换
举例：E:回车，表示切换到E盘
-
dir
说明：查看当前路径下的内容
- cd + 目录/文件夹名
说明：进入单级目录
举例：cd 作业
-
cd…
说明：回退到上一级目录
-
cd 文件夹1\文件夹2…
说明：进入多级目录
举例：cd 作业\操作系统
-
cd \
说明：回退到盘符目录。
-
cls
说明：清屏。
-
exit
说明:退出命令提示符窗口
配置环境变量
把qq的路径记录在电脑的环境变量
把软件的路径配置到环境变量中，可以在任意的目录下打开指定的软件
配置环境变量步骤：
此电脑——空白处右键——属性——收索高级系统设置——高级——环境变量——系统变量——path——编辑——添加路径
java基础语法
java入门
什么是java?
Java是一门面向对象编程语言，不仅吸收了 C++语言的各种优点，还摒弃了 C++里难以理解的多继承、指针等概念，因此 Java语言具有功能强大和简单易用两个特征。Java语言>>>作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立性与可移植性、多线程、动态性等特点。Java可以编写桌面应用程、Web应用程序、分布式系统和嵌入式系统应用程序等。
Java程序初体验
HelloWorld案例的编写
1、用记事本编写程序
2、编译（翻译）文件
3、运行程序
- 编译：javac是JDK提供的编译工具，我们可以通过这个工具，把当前路径下的==.java文件编译成.class==文件
- 运行：java提供一个工具，作用是运行代码，运行.class这个文件夹
BUG
- 中英文符号问题
- 单词拼写，大小写
环境变量
配置环境变量：
此电脑——空白处右键——属性——收索高级系统设置——高级——环境变量——系统变量——新建——变量名（N）：JAVA_HOME +变量值（V）：D:\JDK\jdk8（java.exe和javac.exe所在目录，去掉bin)——点击确定——Path——新建——%JAVA_HOME%\bin——点击确定
Notepad软件
常见的高级记事本：
Editplus、Notepad++、Sublime等
Java开发工具、用途、特性
Java SE
Java SE是java语言的（标准版），用于桌面应用的开发，是其它两个版本的基础。
**桌面应用：**用户只需打开程序，程序的界面会让用在最短的时间内找到他们需要的功能，同时主动带领用户完成他们的工作并得到最好的体验。
学习Java SE的目的是为今后从事的Java EE开发，打基础。
Java ME
Java ME是java语言的（小型版），用于嵌入式电子设备或者小型移动设备。
Java EE
Java EE是java语言的（企业版），用于Web方向的网站开发。
**网站开发：**浏览器+服务器。
Java能做什么？
1、**桌面应用开发：**开发各种各样的工具，如各种税务管理软件，IDEA、Clion、Pycharm、WebStorm（前端开发工具）、PhpStorm(Php开发工具)
2、**企业及应用开发：**微服务、springcloud、淘宝，京东，阿里云(企业级应用：开发服务器)
3、**移动应用的开发：**鸿蒙、android、医疗设备控制管理程序
4、**科学计算工具：**matlab
5、**大数据开发：**hadoop框架
6、**游戏开发：**我的世界MineCraft
Java的特性
- 面向对象：根据模板，把东西创建出来
- 安全性
- 多线程：通俗讲就是同时做多件事情
- 简单易用
- 开源：(1)不开源，例如下载一个QQ,仅仅下载的是QQ的安装包，腾讯公司不会把代码给你
(2)开源，当我们下载Java开发的工具的时候，Orck公司也会把代码给你，安装包和代码都要下载。一旦开源，世界上所有Java的开发者都可以维护Java.
- 跨平台：跨平台中的平台指的是操作系统，Windows、Mac（苹果电脑操作系统）、Linux。跨平台指Java程序可以在任意操作系统上运行
Write Once Run Anywhere 一次编译，到处运行
高级语言的编译运行方式
编程、编译、运行
- **编程：**java程序员写的.java代码，c程序员写的.c代码，python程序员写的.py代码
- **编译:**机器只认01机器语言，把.java、.c、.py的代码做转化让机器认识的过程
- **运行：**让机器执行编译后的指令
高级语言的编译运行方式
- 编译型
- 解释型
- 混合型，半编译，半解释
编译型
c\c++不跨平台
解释型
Python开源
混合型
-
java不是直接运行在系统中的，而是运行在虚拟机中的
-
java语言的跨平台是通过虚拟机实现的
-
针对于不同的操作系统，安装不同的虚拟机就可以了
JRE和JDK
JVM (Java Virtual Machine):Java 虚拟机，真正运行Java程序的地方
开发工具：
- javac编译工具
- java运行工具
- jdb调试工具
- jhat内存分析工具
…
**核心类库：**java已经写好的东西
JDK(Java Development kit):Java开发工具包，用于编写代码，由JVM、核心类库和开发工具组成。
JRE (Java Runtime Environment ): Java的运行环境，与JDK相似，JRE也是由JVM、核心类库、开发工具组成，但区别在于，组成 JRE的开发工具较 JDK少。例如，JRE的开发工具中不需要 javac编译工具，不需要 jdb调试工具，因为在 JRE中运行的是编译后的 .class文件。
Java基础概念
注释
-
**注释：**是在程序指定位置添加的说明性信息，简单理解，就是对代码进行解释说明的文字。
-
注释分类：
-
单行注释：
格式：//注释信息 -
多行注释：
格式：/*注释信息*/ -
文档注释：
格式：/**注释信息**/
-
-
注意：
-
注释的内容不参与编译，也不参与运行，仅仅是对代码的解释说明
-
不管是单行注释还是多行注释，在书写的时候都不要嵌套
-
关键字
**关键字：**被 Java 赋予特定涵义的英文单词
特点:
- 关键字的字母全部小写
- 常用的代码编辑器，针对关键字有特殊的颜色标记，非常的壮观
**关键字class:**用于（创建/定义）一个类，后面跟随类名，类是Java最基本的组成单元
关键字 return：
- 方法没有返回值：可以省略不写。如果书写，表示结束方法
- 方法有返回值：必须要写。表示结束方法和返回结果
字面量（常量）
**字面量:**数据在程序中的类型
| 字面量类型 | 说明 | 举例 |
|---|---|---|
| 整数类型（int) | 不带小数点的数字 | 666、-88 |
| 小数类型（double) | 带小数点的数字 | 13.14、-5.21 |
| 字符串类型（string) | 用双引号括起来的内容，内容可以为空 | “HelloWorld”、“黑马程序员”、" " |
| 字符类型（char) | 用单引号括起来的，内容只能有一个 | ‘A’、‘0’、‘我’、‘b’ |
| 布尔类型（boolean) | 布尔值，表示真假 | 只有两个值：true, false |
| 空类型 | 一个特殊的值，空值 | 值是：null |
**细节：**null不能直接打印
如果我们要打印null，那么只能用字符串的形式进行打印
扩展点：
‘\t’、‘\r’、‘\n’、…
1、\t 制表符：
在打印的时候，把前面字符串的长度补齐到8，或者8的倍数。最少补1个空格，最多补8个空格。
public class HelloWorld{
public static void main (String[] args){
System.out.println("abc" + '\t'); //字符串长度为3，'\t' 表示补5个空格
System.out.println("abcd" + '\t'); //字符串长度为4，'\t' 表示补4个空格
}
}
**作用：**打印时让数据对齐
public class HelloWorld{
public static void main (String[] args){
System.out.println("nameage");
System.out.println("tom23");
}
}
打印效果：
nameage
tom23
public class HelloWorld{
public static void main (String[] args){
System.out.println("name" + '\t' + "age");
System.out.println("tom" + '\t' + "23");
}
}
打印效果：
name age //name后补4个空格
tom 23 //tom后补5个空格
变量
**变量：**在程序的执行过程中，其值有可能发生改变的量（数据）
**变量的使用场景：**当某个数据经常发生改变时，我们也可以用变量存储。当数据变化时，只要修改变量里面记录的值即可。
变量的定义格式：
数据类型 变量名 = 数据值；
"=":作用“赋值”
public class VariableDemo1{
//主入口
public static void main (String[] args){
//定义变量
//数据类型 变量名 = 数据值；
int a = 12;
//输出 a 的值
System.out.println(a);
}
}
运行结果：12
变量的使用方式：
1、输出打印
2、参与计算
3、修改记录的值
public class VariableDemo2{
//主入口
public static void main (String[] args){
//数据类型 变量名 = 数据值；
//1、基本用法
int a = 12;
//输出 a 的值
System.out.println(a);
System.out.println(a);
//2、变量参与计算
int b = 15;
int c = 20;
System.out.println(b + c);
//3、修改变量记录的值
a = 21;
System.out.println(a);
System.out.println("---------------);
//注意事项
//在- 一条语句可以定义多个变量
int d = 100,e = 200,f = 300;
System.out.println(d);
System.out.println(e);
System.out.println(f);
int g;
//System.out.println(g);报错，变量使用前未赋值
g = 600;
System.out.println(g);
}
}
运行结果：
12
12
35
21
--------------------
100
200
300
注意事项：
- 只能存一个值
- 变量名不允许重复定义
- 一条语句可以定义多个变量
- 变量在使用之前一定要进行赋值
- 变量的作用域范围==(变量只能在所属的方法里面有效)==
变量练习：
public class VariableTest{
//主函数入口
public static void main(String[] args){
//定义乘客数量变量,并初始化
int counter = 0;
//第一站，上一个乘客
counter = counter + 1;
//第二站，上两个乘客，下一位乘客
counter = counter + 2 - 1;
//第三站，上两个乘客，下一位乘客
counter = counter + 2 - 1;
//第四站，下一位乘客
counter = counter - 1;
//第五战，上一位乘客
counter = counter + 1;
//输出终点站乘客人数
System.out.println(counter);
}
}
运行结果：
3
计算机的存储规则
**计算机中的3类数据：**文本数据、图片数据、声音数据
-
Text文本，文本数据
-
数字、字母、汉字
-
计算机的存储规则
-
数字：转二进制
-
字母：查询码表
-
汉字：查询码表
-
-
-
Image图片，图片数据
- 黑白图、灰度图、彩色图
- 通过每个像素点中的RGB三原色来存储
- 黑白图、灰度图、彩色图
-
Sound声音，声音数据
- 对声音的波形图进行采样再存储
在计算机中，任意数据都是以二进制的形式来存储的
不同进制在代码中的表现形式：
- 二进制：由 0 和 1 组成，代码中以0b开头
- 十进制；由 0 ~ 9 组成，前面不加任何后缀
- 八进制：由 0 ~ 7 组成，代码中以 0 开头
- 十六进制：由 0 ~ 9 还有 a ~ f 组成，代码中以 0x 开头
显示器的三个知识点：（图片存储）
- 分辨率：2K、4K
- 常见2K，1920*1080，在显示器上宽有1920个小格子，高有1080个小格子，一个小格子成为一个像素
- 常见4K，3840*2160，
- 像素
- 光学三原色
- 红、绿、蓝。也称之为TGB
- 写成十进制形式：（255，255，255）
- 写成十六进制形式：（FF,FF,FF)
数据类型
数据类型的分类：
-
基本数据类型
-
数据类型 关键字 取值范围 字节型 byte -128~127 短整型 short -32768~32768 长整型 long -9223372036854775808~9223372036854775807 整型 int(默认) -2147483648~2147483647 单精度浮点型 float -3.401298e-38~3.402823e+38 双精度浮点型 double(默认) -4.9000000e-324~1.797693e+308 字符型 char 0~65535 布尔型 boolean true, flase 注意:
-
1、在定义 long 类型的变量，在数据值后面需要加上一个 L 作为后缀
long n = 999999L;
2、在定义 float 类型的变量，在数据值后面需要加上一个 F 作为后缀
float f = 10.1F
3、double > float > long > int > short > byte
4、字符型
package just.test;
public class Test3 {
public static void main(String[] args) {
char a = 'a';
char b = ++a;
char c = (char)99;
System.out.println(b);
System.out.println(c);
}
}
运行结果：
b
c
<img src="D:/学习makedown/Java(2)插入的图片/基本数据类型.jpg" alt="基本数据类型" style="zoom:33%;" />
-
引用数据类型
只要是 new 出来的，都是 引用数据类型
例如：数组
练习：
1、练习：输出老师的信息
public class VariableTest2{
//主入口
public static void main(String[] args){
//姓名
string name = "黑马谢广坤";
//年龄
int age = 18;
//性别
char gender = '男';
//身高
double height = 180.1;
//是否结婚,true表示结婚
boolean flag = true;
//输出变量的值
System.out.println(name);
System.out.println(age);
System.out.println(gender);
System.out.println(height);
System.out.println(flag);
}
}
输出结果：
黑马谢广坤
18
男
180.1
true
标识符
**标识符：**就是给类、方法、变量等起的名字。做到，见名知意。
标识符命名规则—硬性要求
- 由 数字、字母、下划线(_) 和 美元符($) 组成
- 不能以数字开头
- 不能是关键字
- 区分大小写
标识符命名规则—软性要求
小驼峰命名法：方法、变量
-
规范1：标识符是一个单词 的时候，全部小写
-
范例1：name
-
规范2：标识符有多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
-
范例2：firstName
大驼峰命名法：类名
- 规范1：标识符是一个单词 的时候，首字母大写**
- 范例1：Student
- 规范2：标识符有多个单词组成的时候，每个单词的首字母大写
- 范例2：GoodStudent
键盘录入
**键盘录入介绍：**Java帮我们写好一个类叫 Scanner,这个类就可以接收键盘输入的数字
Scanner使用步骤：
- 步骤一:导包 — Scanner 这个类在哪
import java.util.Scanner;导包的动作必须出现在类定义的上边
- 步骤二：创建对象 — 表示我要开始用 Scanner 这个类
Scanner sc = new Scanner(System.in);
上面这个格式里面，只有 sc 是变量名，可以变，其他的都不允许变。
- 步骤三：接收数据 — 真正开始干活
int i = sc.nextInt();
左面这个格式里面，只有i是变量名，可以变，其他的都不允许变
//导包，写在类定义的上面
import java.util.Scanner;
public class ScannerDemo1{
public static void main(String[] args){
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入整数：");
//接收数据
//接收数据的代码sc.nextInt()，在键盘输入什么，sc.nextInt()就接受什么。再把接收到的结果，赋值给左边的变量,
int i = sc.nextInt();//变量 i 记录了键盘录入的数据
System.out.println("输出结果：");
System.out.println(i);
}
}
运行结果：
请输入整数：
1234
输出结果：
1234
**练习：**键盘输入数字并求和
需求：键盘录入两个整数，求出它们的和并打印出来。
//导包
inport java.unit.Scanner;
public class ScannerDemo2{
public static void main(String[] args){
//创建对象
Scanner sc = new Scanner(System.in);
//输入两个整数
System.out.println("请输入第一个数字：");
int number1 = sc.nextInt();
System.out.println("请输入第二个数字：");
int number2 = sc.nextInt();
System.out.println("输出两整数之和：");
System.out.println(number1 + number);
}
}
运行结果：
请输入第一个数字：
12
请输入第二个数字：
21
输出两整数之和：
33IDEA
第一套体系
package Just.test;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//键盘录入
//第一套体系
//nextInt(); 接收整数
//nextDouble; 接受小数
//next(); 接收字符串
//遇到空格，制表符，回车就停止接收。这些符号后面的数据就不会接受了
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数");
int num1 = sc.nextInt();
System.out.println(num1);
System.out.println("请输入第二个整数");
int num2 = sc.nextInt();
System.out.println(num2);
System.out.println();
System.out.println("请输入一个字符串");
String arr1 = sc.next();
System.out.println(arr1);
System.out.println("请输入第二个字符串");
String arr2 = sc.next();
System.out.println(arr2);
System.out.println();
}
}
====================================================
运行结果：
请输入一个整数
123 456
123
请输入第二个整数
456
请输入一个字符串
asd fgjk
asd
请输入第二个字符串
fgjk
第二套体系
package Just.test;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//第二套体系
//nextLine(); 接收字符串
//可以接收空格、制表符，遇到回车才停止接受数据
System.out.println("请输入一个字符串");
String line1 = sc.nextLine();
System.out.println(line1);
System.out.println("请输入第二个字符串");
String line2 = sc.nextLine();
System.out.println(line2);
}
}
==========================================================================
运行结果：
请输入一个字符串
asd fghh
asd fghh
请输入第二个字符串
asdfgghh 12555
asdfgghh 12555
输出
sout
1、换行输出：
System.out.println();
2、非换行输出
System.out.print();
souf
非换行输出
System.out.printf("");
souf 输出的参数分为两部分：
(1) 第一部分参数：要输出的内容 + %s (占位)
(2) 第二部分参数：填充的数据
package Just.test;
package Just.test;
public class Test2 {
public static void main(String[] args) {
//souf 两部分参数
//第一部分参数：要输出的内容 + %s(占位）
//第二部分参数：填充的数据
System.out.printf("你好啊%s","张三");//第一部分：你好啊%s 第二部分填充数据：张三
System.out.println();//换行
System.out.printf("%s你好啊%s","张三","李四");//两个占位，需要对应两个 填充数据
}
}
IDEA简介
IDEA概述：IDEA全称 IntelliJ IDEA, 是用于Java语言开发的集成环境，它是业界公认的目前用于 Java 程序开发最好的工具。
集成环境：把代码编写**，编译，执行，调试等多种功能综合到一起的开发工具
IDEA下载和安装
**下载：**https//www.jetbrains.com/idea/
**安装：**建议修改安装路径
IDEA项目结构介绍
1、project(项目)
2、module(模块)，各模块相互独立
3、package(包)，包就是文件夹，在模块里面建很多包，把功能相同的代码放在一个包中
- 第一个文件夹(包)——存放与文字相关的代码
- 第二个文件夹(包)——存放与图片相关的代码
- 第三个文件夹(包)——存放与动画相关的代码
- 第四个文件夹(包)——存放与==…==相关的代码
4、class(类)
总的结构：
project(项目)
module(模块)
package(包)
class(类)
IDEA使用步骤：
New Project——Empty Protect——Next——Project name（给项目取名字）——Project location(项目地址，后面一定要是 \ + 项目名称)——Finish——Modules——点击右上方" + "号——>New Module——Java——Next——Module name(模块名字)——Finish——Ok——展开模块——右键src——New—>———>Package——给“包”起名字（规则：公司域名反写+包的作用——右键包——New——Java Class——输入类名——
- 在给包命名时，一个" . ",代表一级包
快捷键
psvm + 回车
psvm + 回车 自动输入：public static void main(String[] args)
main + 回车
main + 回车 自动输入：public static void main(String[] args)
sout + 回车
sout + 回车 自动输入：System.out.println();
Ctrl + Alt + M
Ctrl + Alt + M 自动抽取方法
Ctrl + d
复制 + 换行
Ctrl + a
Ctrl + a 全选
alt + Fn + insert
alt + Fn + insert ——> Constructor(构造器)——> Select None——> 生成无参构造器
alt + Fn + insert ——> Constructor(构造器)——> 按住 Shift ，点击最下面的那个(Ctrl + a)——> Ok——> 生成有参构造器
alt + Fn + insert ——> Getter and Setter——> Ctrl + a ——>生成每一个私有化成员变量对应的 get 和 set 方法
Ctrl + 左键
Ctrl + 左键 跳转到所选择对象在代码中出现的其他位置
Ctrl + p
Ctrl + p 显示方法参数
Ctrl + b
先选中 ，然后 Ctrl + b 看源码
先选中，然后 Ctrl + b 位移
Ctrl + Alt + t
先选中，然后 Ctrl + Alt + t 选循环
Alt + 鼠标左键
Alt + 鼠标左键， 批量选择
Ctrl + Alt + v
左键选中类中调用的方法 Ctrl + Alt + v 自动生成左边内容
Alt + 回车
选中 Alt + 回车 自动导包
点击报错红线 Alt + 回车 提供解决方案
Ctrl + n
Ctrl + n 输入要搜索的对象，可以查看源码
Ctrl + r
Ctrl + r 更换变量的名字
IDEA的项目和模块操作
IDEA中类相关操作：
1、新建类：想把类新建在哪个包中，就右键那个包，然后 New —— Java.Class——写类名——回车
2、删除类：想删除哪个类，就右键那个类，然后 Delete…——Ok
3、修改类名：想修改哪个类，就右键那个类，然后选择 Refactor——Rename…，点击——弹出小窗，进行修改——点击 Refactor
IDEA中模块相关操作：
1、新建模块：File —— Porject Structure ——Modules ——中间点击 " + "——New Module——Java——Next——Module name(模块名字)——Finish——Yes——Ok.
在某模块时，建立新的模块时，此时模块并立，当新建的模块有类声明后，可以把新模块remove…， 然后单独打开
模块的内容根和模块文件位置一定是：\项目名称\模块名
2、删除模块：
3、修改模块：
4、导入块：
IDEA中项目相关操作：
打开 IntelliJ IDEA 时，默认打开上次操作的项目，
1、关闭项目：关闭某个项目，先选中要关闭的项目，然后点击 File ——Close Project——点击
2、新建项目：New Project——Empty Protect——Next——Project name（给项目取名字）——Project location(项目地址，后面一定要是 \ + 项目名称)——Finish——Yes
3、打开项目：
4、修改项目：
运算符
运算符与表达式
**运算符：**对字面量或者变量进行操作的符号
表达式: 用运算符把字面量或者变量连接起来，符合Java语法和式子就可以称为为表达式。不同运算符连接起来的表达式体现的是不同类型的表达式。
举例说明：
int a = 12;
int b = 15;
int c = a + b;
" + " : 是运算符，并且是算术运算符
“a + b” 是表达式，由于" + " 是算术运算符，所以这个表达式叫算术表达式
算术运算符
基本用法
算术运算符：
| 符号 | 作用 | 说明 |
|---|---|---|
| + | 加 | |
| - | 减 | |
| * | 乘 | |
| / | 除 | 取结果的 商 |
| % | 取余、取模 | 取结果的 余数 |
注意:
-
整数参与运算只能得到整数
-
当有小数参与运算时，计算结果可能不准确
-
取模的应用场景
- 1、可以用取模来判断，A 是否可以被 B 整除。 A % B
- 2、可以判断 A 是否为偶数。 A % 2，结果为 0 ，则 A 为偶数，结果为 1，则 B 为奇数
练习：
需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
公式总结：
个位：数值 / 1 % 10
十位：数值 / 10 % 10
百位：数值 / 100 % 10
千位：数值 / 1000 % 10
…
package Just.test;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//键盘录入一个三位数，获取其中的个位十位百位
//1、键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();
//2、获取个位、十位、百位
int unit = number % 10;
int decade = number / 10 % 10;
int hundred = number / 100 % 10;
System.out.println("输出三位数的个位、十位、百位");
System.out.println(unit);
System.out.println(decade);
System.out.println(hundred);
}
}
请输入一个三位数
289
输出三位数的个位、十位、百位
9
8
2
高级用法
" + " : 操作的三种情况
1、数字的 " + " 操作
-
数字进行运算时，数据类型不一样不能运算，需要转成一样的，才能运算
-
隐式转换(自动类型提升)
- 把一个取值范围小的数值，转成取值范围大的数据
- 取值范围 (由小到大）：byte——>short——>int——>long——>float——>double
- 隐式转换的两种提升原则：
- 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算
- byte 、short 、char 三种类型的数据在运算的时候，都会直接先提升为 int ，然后再进行运算
-
强制转换：
-
如果把一个取值范围的数值，赋值给取值范围小的变量。是不允许直接赋值的，如果一定要这么做，就需要加入强制转换。
-
格式：目标数据类型 变量名 = （目标数据类型） 被强转的数据;
-
范例：
- 范例1
-
-
double a = 123;
int b = (int)a;
- 范例2
package Just.arithmeticoperator;
public class ArithmeticoperatorDemo3 {
public static void main(String[] args) {
byte b1 = 10;
byte b2 = 12;
//把 b1 + b2 的和转成 byte 类型
byte result = (byte)(b1 + b2);
System.out.println(result);
}
}
运行结果：
22
2、字符串的 " + " 操作
-
当 " + "操作中出现字符串时，这个 " + " 是字符串连接符，而不是算术运算符了。会将前后的数据进行拼接，并产生一个新的字符串。
-
范例：
“123” + 123 ——> “123123”
-
-
连续进行 " + " 操作时，从左到右逐个执行
-
范例：
1 + 99 + “年黑马” ——>100 + “年黑马” —— “100年黑马”
-
-
练习：
System.out.println(3.7 + "abc");//"3.7abc"
System.out.println("abc" + true);//"abctrue"
System.out.println('中' + "abc" + true);//"中abctrue"
int age = 18;
System.out.println("我的年龄是" + age + "岁" );//"我的年龄是18岁"
System.out.println("我的年龄是" + "age" + "岁");//"我的年龄是age岁"
System.out.println(1 + 2 + "abc" + 2 +1);//"3abc21"
3、字符的 “ + ” 操作
-
当 字符 + 字符 // 字符 + 数字 时，会把字符通过 ASCII 码表查询到对应的数字再进行计算。
-
练习：
System.out.println(1 + 'a'); // 1 + 97
System.out.println('a' + "abc"); //"aabc"
自增自减运算符
基本用法
| 符号 | 作用 | 说明 |
|---|---|---|
| ++ | 加 | 变量的值加 1 |
| – | 减 | 变量的值减 1 |
注意事项：
++ 和 --即可以放在变量的前面，也可以放在变量的后面。
两种用法：
1、单独使用
++ 和 – 无论是放在变量的前面还是后面，单独写一行 结果是一样的。
2、参与计算
-
++
- 后 ++，先用后加
int a = 10;
int b = a++;
结果：
a = 11;
b = 10;
- 前 ++，先加后用
int a = 10;
int b = ++a;
结果：
a = 11;
b = 11;
-
–
- 后 --，先用后减
int a = 12;
int b = a--;
结果：
a = 11;
b = 12;
-
先 --，先减后用
int a = 12; int b = --a; 结果： a = 11; b = 11;
赋值运算符
分类：
| 符号 | 作用 | 说明 |
|---|---|---|
| = | 赋值 | int a =10 ; 将10的值赋给a |
| += | 加后赋值 | a += b , 及 a = a + b; |
| -= | 减后赋值 | a -= b , 及 a = a - b; |
| *= | 乘后赋值 | a *= b , 及 a = a * b; |
| /= | 除后赋值 | a /= b , 及 a = a / b; |
| %= | 取余后赋值 | a %= b , 及 a = a % b; |
注意： +=、-=、*=、/= 和 %= ，底层都隐藏了一个强制类型的转换
关系(比较）运算符
关系 / 比较 运算符的分类：
| 符号 | 说明 |
|---|---|
| == | a == b ,判断 a 和 b 的值是否相等，成立为 true, 不成立为 false |
| ！= | a != b ,判断 a 和 b 的值是否不相等，成立为 true, 不成立为 false |
| > | a > b ,判断 a 是否大于 b, 成立 true, 不成立 flase |
| >= | a >= b ,判断 a 是否大于等于 b，成立 true, 不成立 flase |
| < | a < b , 判断 a 是否 小于 b , 成立 true, 不成立 flase |
| <= | a <= b , 判断 a 是否 小于等于 b , 成立 true, 不成立 flase |
注意事项：
- 关系运算符的结果都是boolean类型，要么是 true ,要么是 false。
- 千万不要把 " == " ,误写成 " = "
练习：约会
需求：
你和你的约会对象在餐厅里面正在约会。
键盘录入两个整数，表示你和你约会对象衣服的时髦度。（手动录入 0 ~ 10 之间的整数，不能录入其他）
如果你的时髦程度大于你对象的时髦程度，相亲成功，输出 true。
否则输出 false。
package Just.test;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
//键盘录入两个整数表示衣服的时髦度
Scanner sc = new Scanner(System.in);
System.out.println("请输入我们自己的衣服时髦度：");
int myFashion = sc.nextInt();
System.out.println("请输入相亲对象衣服的时髦度：");
int girlFashion = sc.nextInt();
//比较结果
boolean result = myFashion > girlFashion;
System.out.println(result);
}
}
运行结果：
请输入我们自己的衣服时髦度：
5
请输入相亲对象衣服的时髦度：
4
true
逻辑运算符
分类：
| 符号 | 作用 | 说明 |
|---|---|---|
| & | 逻辑与（且） | 并且，两边都为真，结果才是真 |
| | | 逻辑或 | 或者，两边都为假，结果才是假 |
| ^ | 逻辑异或 | 相同为 flase ,不同为 true |
| ! | 逻辑非 | 取反 |
package Just.logicoperator;
public class LogicoperatorDemo1 {
public static void main(String[] args) {
// & 并且，两边都为真，结果才真
System.out.println(true & true);//true
System.out.println(false & false);//flase
System.out.println(true & false);//flase
System.out.println(false & true);//flase
// | 或，两边都为假，结果才是假
System.out.println(true | true);//true
System.out.println(false | false);//flase
System.out.println(true | false);//true
System.out.println(false | true);//true
// ^ 异或，相同为 false,不同为 true
System.out.println(true ^ true);//flase
System.out.println(false ^ false);//flase
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
// !，逻辑非，取反
System.out.println(!false);//true
System.out.println(!true);//flase
}
}
短路逻辑运算符
分类：
| 符号 | 作用 | 说明 |
|---|---|---|
| && | 短路 与 | 结果和 & 相同，但是有短路效果 |
| || | 短路 或 | 结果和 | 相同，但是有短路效果 |
package Just.logicoperator;
public class LogicoperatorDemo3 {
public static void main(String[] args) {
//&& 与
System.out.println(true && true);//true
System.out.println(false && false);//false
System.out.println(true && false);//false
System.out.println(false && true);//false
System.out.println();
// || 或
System.out.println(true || true);//true
System.out.println(false || false);//false
System.out.println(true || false);//true
System.out.println(false || true);//true
System.out.println();
//短路逻辑运算符具有短路效果，当左边的表达式能确定最终的结果，那么右边就不会参与运行
int a = 10;
int b = 10;
boolean result = ++a < 5 && ++b < 5;
System.out.println(result);//false
System.out.println(a);//11
System.out.println(b);//10
System.out.println();
//
a = 10;
b = 10;
boolean result1 = ++a < 5 & ++b < 5;
System.out.println(result1);//false
System.out.println(a);//11
System.out.println(b);//11
}
}
注意事项：
- && : 左边为 false ,右边不管是真是假，整个表达式的结果一定是 false
- || : 左边为 true ,右边不管是真是假，整个表达式的结果一定是 true
- 最常用的逻辑运算符：&& , || , !
练习：数字6
需求：
数字6是一个真正伟大的数字，键盘录入两个整数。
如果其中一个为6，最终结果输出 true
如果他们的和为6的倍数。最终结果输出true
其他情况都是false
package Just.test;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("输入第一个数：");
int number1 = sc.nextInt();
System.out.println("输入第二个数：");
int number2 = sc.nextInt();
int sum = number1 + number2;
boolean result = number1==6 || number2==6 || sum % 6==0;
System.out.println(result);
}
}
运行结果：
输入第一个数：
3
输入第二个数：
2
false
三元运算符
（三元运算符 / 三元表达式）格式
- 格式：关系表达式==？表达式1：==表达式2；
范例：求两个数的较大值
int max = a > b ? a : b ; //结果赋值给变量
System.out.println(a > b ? a : b); //结果直接打印
package Just.ternaryoperator;
public class TernaryoperatorDemo1 {
public static void main(String[] args) {
//定义两个变量
int number1 = 12;
int number2 = 15;
//使用三元运算符获取两个整数中的较大值
int max = number1 > number2 ? number1 : number2;
System.out.println(max);
}
}
**练习：**两只老虎
需求：动物园里有两只老虎，体重分别为通过键盘录入获得，
请用程序实现判断两只老虎的体重是否相同。
package Just.test;
import java.util.Scanner;
public class Test4 {
public static void main(String[] args) {
//键盘录入两只老虎的体重
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一只老虎的体重：");
int weight1 = sc.nextInt();
System.out.println("请输入第二纸老虎的体重：");
int weight2 = sc.nextInt();
//输出结果
String result = weight1 == weight2 ?"相同" : "不相同";
System.out.println(result);
}
}
运行结果：
请输入第一只老虎的体重：
158
请输入第二纸老虎的体重：
149
不相同
**练习：**三个和尚
需求：一座寺庙里住着三个和尚，以知他们的身高
分别为150cm、210cm、165cm，
请用程序实现获取这三个和尚的最高身高
package Just.test;
public class Test5 {
public static void main(String[] args) {
//三个和尚的身高
int height1 = 150;
int height2 = 210;
int height3 = 165;
//获取三个和尚最高身高
int temp = height2 > height3 ? height2 : height3;
int result = height1 > temp ? height1 : temp;
//输出
System.out.println("三个和尚的最高身高为：");
System.out.println(result);
}
}
运行结果：
三个和尚的最高身高为：
210
运算符的优先级
注意： ( ) 优先于所有，写代码时，想让谁优先计算，直接用 ( ), 括起来。
原码、反码、补码
**源码：**十进制数据的二进制表现形式 ，最左边是符号位 ，0为正 ，1为负。
**反码：**正数的反码是其本身 ，负数的反码是符号位保持不变 ，其余位取反，0——>1 , 1——>0。
**补码：**正数的补码是其本身，负数的补码是在其反码的基础上 + 1。
bit ：比特位，二进制的基本单位；
1 字节 = 8 比特位
判断和循环
流程控制语句
顺序结构
顺寻结构语句是 Java 程序默认的执行流程，按照代码的先后顺序，从上到下依次执行
package Just.orderdemo;
public class OrderDemo {
public static void main(String[] args) {
System.out.println("床前明月光");
System.out.println("疑是地上霜");
System.out.println("举头望明月");
System.out.println("低头思故乡");
}
}
运行结果：
床前明月光
疑是地上霜
举头望明月
低头思故乡
分支结构
If
If 语句 ：表示判断
1、If 语句的第一种格式：
if (关系表达式){
语句体；
}
执行流程：
- 首先计算关系表达式的值
- 如果关系表达式的值为 true ,就执行语句体
- 如果关系表达式的值为 false ,就不执行语句体
- 继续执行后面的其他语句
**练习：**老丈人选女婿
需求：键盘录入女婿酒量，如果大于2斤，老丈人给出回应，反之不回应
package Just.ifDemo;
import java.util.Scanner;
public class IfDemo1 {
public static void main(String[] args) {
//键盘录入女婿酒量
Scanner sc = new Scanner(System.in);
System.out.println("请输入女婿的酒量：");
int wine = sc.nextInt();
//对酒量进行判断
if(wine > 2){
System.out.println("小伙子，不错呦！！");
}
}
}
运行结果：
请输入女婿的酒量：
3
小伙子，不错呦！！
注意事项：
- 大括号的开头可以另起一行书写，但是建议写在第一行的末尾
- 在语句体中，如果只有一句代码，大括号可以省略不写。个人建议，大括号还是不要省略
- 如果对一个布尔类型的变量进行判断，不要用 == 号，直接把变量写在小括号里即可
**练习：**自动驾驶，红灯停，绿灯行，黄灯等
package Just.test;
public class Test2 {
public static void main(String[] args) {
//定义灯的状态
boolean isLightGreen = false;
boolean isLightYellow = false;
boolean isLightRed = true;
//输出车的行为
if(isLightGreen){
System.out.println("GoGoGo!!!");
}
if(isLightYellow){
System.out.println("Wait!!!");
}
if(isLightRed){
System.out.println("Stop!!!");
}
}
}
运行结果：
Stop!!!
2、If 语句的第二种格式
if (关系表达式){
语句体1；
}else{
语句体2；
}
执行流程：
- 首先计算关系表达式的值
- 如果关系表达式的值为 true 就执行语句体1
- 如果关系表达式的值为 false 就执行语句体2
- 继续执行后面的其他语句
**练习：**吃饭
需求：键盘录入一个整数，表示身上的钱。如果大于等于100块，就吃网红餐厅。否则，就吃经济实惠的沙县小吃。
package Just.test;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//键盘录入身上的钱
Scanner sc = new Scanner(System.in);
System.out.println("请输入身上的钱：");
int money = sc.nextInt();
if(money > 100){
System.out.println("吃网红餐厅");
}
else{
System.out.println("吃沙县小吃");
}
}
}
运行结果：
请输入身上的钱：
88
吃沙县小吃
**练习：**商品付款
在实际开发中，如果要根据两种不同的情况来执行不同的代码，就需要用到 if 的第二种格式。
需求：
假设，用户在超市实际购买商品总价为：600元。
键盘录入一个整数表示用户实际支付的钱。
如果付款大于等于600，表示付款成功。否则付款失败。
package Just.test;
import java.util.Scanner;
public class Test4 {
public static void main(String[] args) {
//键盘录入支付的钱
Scanner sc = new Scanner(System.in);
System.out.println("请输入顾客所实际支付的钱：");
int pay = sc.nextInt();
if(pay > 600){
System.out.println("付款成功");
}
else{
System.out.println("付款失败");
}
}
}
运行结果：
请输入顾客所实际支付的钱：
666
付款成功
**练习：**影院选座
在实际开发中，电影院选座也会使用到 if 判断。
建设某影院售卖了100张票，票的序号为1~ 100。
其中奇数票号坐左侧，偶数票号坐右侧。
键盘录入一个整数表示电影票的票号。
根据不同情况，给出不同的提示：
如果票号是奇数，那么打印坐左边；
如果票号为偶数，那么打印坐右边。
package Just.test;
import java.util.Scanner;
public class Test5 {
public static void main(String[] args) {
//键盘录入票号
Scanner sc = new Scanner(System.in);
System.out.println("请输入票号：");
int member = sc.nextInt();
//判断票号的真假
if(member > 0 && member <=100){
//判断位置
if(member % 2==0){
System.out.println("坐右边");
}
else{
System.out.println("坐左边");
}
}
else{
System.out.println("票号为假");
}
}
}
运行结果：
请输入票号：
102
票号为假
请输入票号：
66
坐右边
3、If 语句的第三种格式
if (关系表达式1){
语句体1；
}else if(关系表达式2){
语句体2；
}
...
else{
语句体 n + 1;
}
执行流程：
- 首先计算关系表达式1的值
- 如果为 true 就执行语句体 1；如果为 false 就计算关系表达式 2的值
- 如果为 true 就执行语句体 2 ；如果为 false 就计算关系表达式3的值
- …
- 如果所有关系表达式结果都为 false ,就执行语句体 n + 1
总结：
从上往下依次进行判断
只要有一个判断为真，就执行对应的语句体
如果所有的判断都为假，就执行 else 的语句体
**练习：**小明的礼物
根据不同的分数送不同的礼物。
如果是 95 ~ 100分，送自行车一辆
如果是 90 ~ 94分，送游乐场玩一天
如果是 80 ~ 89分，送变形金刚一个
如果是 80 分及以下，揍一顿。
package Just.test;
import java.util.Scanner;
public class Test6 {
public static void main(String[] args) {
//键盘录入小明的成绩
Scanner sc = new Scanner(System.in);
System.out.println("输入小明的成绩为：");
double score = sc.nextDouble();
if(score > 0 && score <= 100){
if(score >= 95 && score <= 100){
System.out.println("送自行车一辆");
}else if(score >= 90 && score <= 94){
System.out.println("游乐场玩一天");
}else if(score >= 80 && score <=89){
System.out.println("送变形金刚一个");
}else{
System.out.println("揍一顿");
}
}else{
System.out.println("录入的成绩不合法");
}
}
}
运行结果：
输入小明的成绩为：
88
送变形金刚一个
输入小明的成绩为：
120
录入的成绩不合法
**练习：**商品的价格
在实际开发中，多种情况判断时，会用到 if 的第三种格式：
需求：
商场都会有 VIP 的会员制，根据不同的会员会有不同的折扣
建设商品的总价为1000
键盘录入会员级别，并计算实际支付的钱
会员 1 级：打9折
会员 2 级：打8折
会员 3 级：打7折
非会员：不打折
package Just.test;
import java.util.Scanner;
public class Test7 {
public static void main(String[] args) {
//定义变量记录总价
int price = 1000;
//键盘录入会员等级
Scanner sc = new Scanner(System.in);
System.out.println("输入会员的等级：");
int grade = sc.nextInt();
if(grade == 1){
System.out.println("会员 1 级，打 9 折");
System.out.println("需要支付： " + price * 0.9);
}else if(grade == 2){
System.out.println("会员 2 级，打 8 折");
System.out.println("需要支付： " + price * 0.8);
}else if(grade == 3){
System.out.println("会员 3 级，打 7 折");
System.out.println("需要支付： " + price * 0.7);
}else{
System.out.println("非会员，不打折");
}
}
}
运行结果：
输入会员的等级：
3
会员 3 级，打 7 折
需要支付： 700.0
输入会员的等级：
1
会员 1 级，打 9 折
需要支付： 900.0
输入会员的等级：
5
非会员，不打折
需要支付： 1000
4、总结：
- if 的第一种格式，适用于一种情况的判断
- if 的第二种格式，适用于两种情况的判断
- if 的第三种格式，适用于多种情况的判断
switch
switch 语句格式：
switch(表达式){
case 值1：
语句体1；
break;
case 值2：
语句体2；
break;
case 值3：
语句体3；
break;
...
default:
语句体 n + 1;
break;
}
执行过程：
- 首先计算表达式的值。
- 依次和 case 后面的值进行比较，如果有对应的值，就会执行相应的语句，在执行过程中，遇到 break 就会结束。
- 如果所有的 case 后面的值和表达式的值都不配，就会执行 default 里面的语句体，然后结束整个 switch 语句。
格式说明：
- 表达式 ：（将要匹配的值）取值为 byte、short、int、char。JDK5以后可以是枚举，JDK7以后可以是 String.
- case : 后面跟的是要和表达式进行比较的值（被匹配的值）
- break : 表示中断，结束的意思，用来结束 switch 语句。
- default : 表示所有情况都不匹配的时候，就执行该处的内容，和 if 语句的 else 相似。
- case : 后面的值只能是字面量，不能是变量
- case : 给出的值不允许重复。
package Just.switchdemo;
import java.util.Scanner;
public class SwitchDemo1 {
public static void main(String[] args) {
//键盘录入想吃的面
Scanner sc = new Scanner(System.in);
System.out.println("输入想吃的面：");
String noodles = sc.next();//输入字符串型变量
switch(noodles){
case "兰州拉面":
System.out.println("吃兰州拉面");
break;
case "武汉热干面":
System.out.println("吃武汉热干面");
break;
case "北京杂酱面":
System.out.println("吃北京杂酱面");
break;
case "陕西油泼面":
System.out.println("吃陕西油泼面");
break;
default:
System.out.println("吃方便面");
break;
}
}
}
运行结果：
输入想吃的面：
武汉热干面
吃武汉热干面
练习：运动计划
需求：键盘录入星期数，显示今天的减肥活动。
周一：跑步
周二：游泳
周三：慢走
周四：动感单车
周五: 拳击
周六：爬山
周日：好好吃一顿
package Just.test;
import java.util.Scanner;
public class Test9 {
public static void main(String[] args) {
//键盘录入星期
Scanner sc = new Scanner(System.in);
System.out.println("输入今天的星期数：");
int number = sc.nextInt();
switch (number){
case 1:
System.out.println("跑步");
break;
case 2:
System.out.println("游泳");
break;
case 3:
System.out.println("漫步");
break;
case 4:
System.out.println("动感单车");
break;
case 5:
System.out.println("拳击");
break;
case 6:
System.out.println("爬山");
break;
case 7:
System.out.println("好好吃一顿");
break;
default:
System.out.println("没有这个星期数");
break;
}
}
}
运行结果：
输入今天的星期数：
3
漫步
输入今天的星期数：
8
没有这个星期数
switch 其他知识点
1、default 的位置和省略
- 位置：default 不一定是写在最下面的，我们可以写在任意位置。只不过习惯写在最下面
package Just.switchdemo;
public class SwitchDemo2 {
public static void main(String[] args) {
int number = 10;
switch (number){
case 1:
System.out.println("number 的值为 1");
break;
default:
System.out.println("number 的值不是 1，10或者20");
break;
case 10:
System.out.println("number 的值为 10");
break;
case 20:
System.out.println("number 的值为 20");
break;
}
}
}
运行的结果：
number 的值为 10
- 省略：default 可以省略，语法不会有问题，但是不建议省略。
package Just.switchdemo;
public class SwitchDemo2 {
public static void main(String[] args) {
int number = 1;
switch (number){
case 1:
System.out.println("number 的值为 1");
break;
case 10:
System.out.println("number 的值为 10");
break;
case 20:
System.out.println("number 的值为 20");
break;
}
}
}
运行结果：
number 的值为 1
2、case 穿透
-
case 穿透：就是语句体中没有写 break 导致的
-
执行流程：
首先还是会拿着小括号中表达式的值跟下面每一个 case 进行匹配。
如果匹配上了，就会执行对应的语句体，如果此时发现了 break ,那么结束整个 switch 语句
如果没有发现 break ，那么程序会继续执行下一个 case 的语句体，一直遇到 break 或者大括号为止
-
使用场景：
如果多个 case 的语句体重复了，那么我们考虑用 case 穿透去简化代码。
package Just.switchdemo;
public class SwitchDemo3 {
public static void main(String[] args) {
int number = 10;
switch (number){
case 1:
System.out.println("number 的值为 1");
break;
case 10:
System.out.println("number 的值为 10");
//break;
case 20:
System.out.println("number 的值为 20");
break;
default:
System.out.println("number 的值不是 1，10或者20");
break;
}
}
}
运行结果：
number 的值为 10
number 的值为 20
3、switch新特性
省略
4、switch 和 if 第三种格式各自的使用场景
- if 的第三种格式：一般用于对范围的判断
- switch 把有限个数据 一 一 列举出来，让我们任选其一
**练习：**休息日和工作日
需求：键盘录入星期数，输出工作日、休息日。
(1 - 5)工作日，(6 - 7)休息日
package Just.test;
import java.util.Scanner;
public class Test10 {
public static void main(String[] args) {
//键盘录入星期数
Scanner sc = new Scanner(System.in);
System.out.println("输入星期数：");
int week = sc.nextInt();
switch (week){
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("工作日");
break;
case 6:
case 7:
System.out.println("休息日");
break;
}
}
}
运行结果：
输入星期数：
5
工作日
**练习：**用户选择
在实际开发中，如果我们需要在多种情况下选择其中一个，就可以使用 switch 语句。
当我们拨打了某些服务电话时，一般都会有按键选择。
假设现在我们拨打了一个机票预订电话。
电话中语音提示：
1、机票查询
2、机票预定
3、机票改签
4、退出服务
其他按键也是退出服务。请使用 switch 模拟该业务逻辑。
package Just.test;
import java.util.Scanner;
public class Test11 {
public static void main(String[] args) {
//键盘录入我们的选择
Scanner sc = new Scanner(System.in);
System.out.println("请输入所选择序号：");
int chose = sc.nextInt();
switch(chose){
case 1:
System.out.println("机票查询");
break;
case 2:
System.out.println("机票预订");
break;
case 3:
System.out.println("机票改签");
break;
case 4:
System.out.println("退出服务");
break;
default:
System.out.println("退出服务");
break;
}
}
}
运行结果：
请输入所选择序号：
2
机票预订
请输入所选择序号：
8
退出服务
循环结构
for循环
格式：
for(初始化;条件判断;条件控制){
循环体语句；
}
执行流程：
1、执行初始化语句
2、执行条件判断语句，看其结果是 true 还是 false
如果是 false ，循环结束
如果是 true ， 执行循环体语句
3、执行条件控制语句
4、回到 2 继续执行条件判断语句
注意：
- 初始化语句只执行一次
- 判断语句为 true ,循环继续
- 判断语句为 false ，循环结束
package Just.loopdemo;
public class ForDemo1 {
public static void main(String[] args) {
for(int i = 0 ;i < 5 ;i++){
System.out.println("HelloWorld");
}
}
}
运行结果：
HelloWorld
HelloWorld
HelloWorld
HelloWorld
HelloWorld
package Just.test;
public class Test12 {
public static void main(String[] args) {
for(int i = 1;i <= 5;i++){
System.out.print(i);
}
System.out.println();
for(int i = 1;i <= 5;i++){
System.out.print(6 - i);
}
}
}
运行结果：
12345
54321
**练习：**断线重连
在实际开发中，需要重复执行的代码，会选择循环实现
比如：玩游戏的时候，如果网不好那么会经常断线重连
那么断线重连这个业务逻辑就需要重复执行。
假设现在公司要求，断线重连的业务逻辑最多只写 5 次
请用代码实现：
备注：断线重连的业务逻辑可以用输出语句替代。
package Just.test;
public class Test13 {
public static void main(String[] args) {
for(int i = 1;i <= 5;i++){
System.out.println("第" + i +"次执行断线重连的业务逻辑");
}
}
}
运行结果：
第1次执行断线重连的业务逻辑
第2次执行断线重连的业务逻辑
第3次执行断线重连的业务逻辑
第4次执行断线重连的业务逻辑
第5次执行断线重连的业务逻辑
**练习：**求和
需求：在实际开发中，如果要获取一个范围中的每一个数据时，也会用到循环。
比如：求 1 - 5 之间的和
package Just.test;
public class Test14 {
public static void main(String[] args) {
int sum = 0;
for(int i = 1;i <= 50;i++){
sum = sum + i;
// System.out.println(sum);
}
System.out.println("输出累加的和为：");
System.out.println(sum);
}
}
运行结果：
输出累加的和为：
1275
注意：
如果我们把变量定义在循环的里面，那么当前变量只能在本次循环中有效
当本次循环结束之后，变量就会从内存中消失
第二次循环开始的时候，又会重新定义一个新的变量。
**练习：**求和
需求：在实际开发中，如果要获取一个范围中的每一个数据时，会用到循环。
但是此时，大多数情况下，不会获取所有的数据，而是获取其中符合要求的数据。
此时就需要循环和其他语句结合使用了。
比如:求 1 - 100 之间的偶数和
package Just.test;
public class Test15 {
public static void main(String[] args) {
int sum = 0;
for(int i = 1;i <= 100;i++){
if(i % 2 == 0){
sum = sum + i;
}
}
System.out.println("输出 1~100之间的偶数和");
System.out.println(sum);
}
}
运行结果：
输出 1~100之间的偶数和
2550
**练习：**统计满足条件的数字
需求：键盘录入两个数字，表示一个范围
统计这个范围中。
既能被 3 整除，用能被 5 整除数字有多少个？
package Just.test;
import java.util.Scanner;
public class Test16 {
public static void main(String[] args) {
//键盘录入两个数字
Scanner sc = new Scanner(System.in);
System.out.println("请录入一个数字表示范围的开始：");
int start = sc.nextInt();
System.out.println("请录入一个数字表示范围的结束：");
int end = sc.nextInt();
//定义统计变量
int number = 0;
for(int i = start;i <=end;i++ ){
if(i % 3 == 0 && i % 5 == 0 ){
System.out.print(i + "、");
number = number + 1;
}
}
System.out.println();
System.out.println("输出能被3和5同时整除的个数；");
System.out.println(number);
}
}
运行结果：
请录入一个数字表示范围的开始：
20
请录入一个数字表示范围的结束：
60
30、45、60、
输出能被3和5同时整除的个数；
3
while
while 循环的执行流程
初始化语句；
while (条件判断语句){
循环体语句；
条件控制语句；
}
循环下面的其他语句
注意：
- 初始化语句只执行一次
- 判断语句为 true ,循环继续
- 判断语句为 false,循环结束
package Just.whiledemo;
public class WhileDemo1 {
public static void main(String[] args) {
//打印换行变量
int number = 0;
int i = 1;
while(i <= 100){
System.out.print(i + "、 " );
number++;
//每行10个数字
if(number % 10 == 0){
System.out.println();
}
i++;
}
}
}
运行结果：
1、 2、 3、 4、 5、 6、 7、 8、 9、 10、
11、 12、 13、 14、 15、 16、 17、 18、 19、 20、
21、 22、 23、 24、 25、 26、 27、 28、 29、 30、
31、 32、 33、 34、 35、 36、 37、 38、 39、 40、
41、 42、 43、 44、 45、 46、 47、 48、 49、 50、
51、 52、 53、 54、 55、 56、 57、 58、 59、 60、
61、 62、 63、 64、 65、 66、 67、 68、 69、 70、
71、 72、 73、 74、 75、 76、 77、 78、 79、 80、
81、 82、 83、 84、 85、 86、 87、 88、 89、 90、
91、 92、 93、 94、 95、 96、 97、 98、 99、 100、
for 和 while 的对比
***相同点：***运行规则都是一样的
for 和 while 的区别：
- for 循环中：知到循环次数或者循环的范围
- while 循环：不知道循环的次数和范围，只知道循环的结束条件
**练习：**打印折纸的次数
需求：世界最高峰是珠穆朗玛峰（8844.43米=8844430毫米），假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度？
package Just.test;
public class Test17 {
public static void main(String[] args) {
//计数器 number
int number = 0;
//纸张的初始厚度
double i = 0.1;
while(i <= 8844430){
//折一次，纸张厚度为原来的两倍
i = i * 2;
//每折一次，计数器计数加一
number = number + 1;
}
System.out.println("输出纸张折叠的次数: ");
System.out.println(number);
}
}
运行结果：
输出纸张折叠的次数:
27
**练习：**回文数
需求：给你一个整数 x。
如果 x 是一个回文数，打印 true ，否则，返回 false
解释：回文数是指正序(从左到右) 和倒序(从右到左)读都是一样的整数。
例如，121是回文数，而123不是
package Just.test;
public class Test18 {
public static void main(String[] args) {
//定义数字
int x = 12345;
int temp = x;
//记录倒过来之后的结果
int number = 0;
while (x != 0){
//从右往左获取每一个数字
int unit = x % 10;
//修改一下 x 记录的值
x = x / 10;
//把当前获取的数字拼接到最右边
number = number * 10 + unit;
}
System.out.println("12345反过来为；");
System.out.println(number);
System.out.println("判断是否为回文数：");
System.out.println(number == temp);
}
}
运行结果：
12345反过来为；
54321
判断是否为回文数：
false
**核心思路:**把数字倒过来跟原来的数字进行比较。
**练习：**求商和余数
需求：给定两个整数，被除数和除数(都是正数，且不超过 int 的范围)。
将两数相除，要求不使用乘法、除法和 % 运算符。
得到商和余数。
package Just.test;
import java.util.Scanner;
public class Test19 {
public static void main(String[] args) {
//键盘录入被除数和除数
Scanner sc = new Scanner(System.in);
System.out.println("键盘录入被除数：");
int dividend = sc.nextInt();
System.out.println("键盘录入除数：");
int divisor = sc.nextInt();
//记录商和余数
int discuss = 0;
int remainder = 0;
while(dividend >=divisor){
dividend = dividend - divisor;
discuss = discuss + 1;
}
remainder = dividend;
System.out.println("输出商为：");
System.out.println(discuss);
System.out.println("输出余数为：");
System.out.println(remainder);
}
}
键盘录入被除数：
61
键盘录入除数：
15
输出商为：
4
输出余数为：
1
do…while
格式:
初始化语句；
do{
循环体语句；
条件控制语句；
}while(条件判断语句)
注意：
- 限制性后判断
循环高级综合练习
无限循环
**无限循环：**循环一直停不下来
1、for 循环的无限循环
for( ; ; ){
System.out.println("学习")；
}
2、while 循环的无限循环
while(true){
System.out.println("学习")；
}
3、do…while 循环的无限循环
do{
System.out.println("学习")；
}while(true)
**注意：**最常用 while 无限循环
package Just.infiniteloopDemo;
public class InfiniteloopDemo1 {
public static void main(String[] args) {
//for 格式的无限循环
/*for(;;){
System.out.println("学习");
}*/
//while 格式的无限循环
while(true){
System.out.println("sb");
}
}
}
注意事项：
无限循环的下面不能再写其他代码了，因为循环永远停不下来，那么下面的代码永远都执行不到
跳转控制语句
1、continue 结束本次循环，继续下次循环
**练习：**小老虎吃包子
小老虎吃包子，第三个包子有虫子，跳过。
package Just.infiniteloopDemo;
public class InfiniteloopDemo2 {
public static void main(String[] args) {
for(int i = 1;i <= 5;i++){
if(i == 3){
//结束本次循环，继续下次循环
continue;
}
System.out.println("小老虎在吃第" + i + "个包子");
}
}
}
运行结果：
小老虎在吃第1个包子
小老虎在吃第2个包子
小老虎在吃第4个包子
小老虎在吃第5个包子
2、break结束整个循环
**练习:**小老虎吃包子
小老虎吃包子，吃完第三个就饱了
package Just.infiniteloopDemo;
public class InfiniteloopDemo3 {
public static void main(String[] args) {
for(int i = 1;i <= 5;i++){
System.out.println("小老虎在吃第" + i + "个包子");
if(i == 3){
//结束整个循环
break;
}
}
}
}
运行结果：
小老虎在吃第1个包子
小老虎在吃第2个包子
小老虎在吃第3个包子
3、return
**ruturn 😗*其实跟循环没有什么关系，跟方法有关的，表示 1 结束循环、2 返回结果
如果方法执行到了 return,那么整个方法全部结束，里面的循环也会随之结束了。
**练习：**判断是否存在
需求：定义一个方法判断数组中的某个数是否存在，将结果返回个调用处
import java.util.Scanner;
public class Test7 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {12,34,56,78,90,58,39,42,93,63,81};
//输入待判定的数
Scanner sr = new Scanner(System.in);
System.out.println("输入待判定的数:");
int number = sr.nextInt();
System.out.println(contains(number,arr));
}
//定义一个方法，判断数组中的数是否存在，将结果返回给调用处
public static boolean contains(int number,int[] arr){
for (int i = 0; i < arr.length; i++) {
if(number == arr[i]) {
return true;
}
}
return false;
}
}
运行结果：
输入待判定的数:
90
true
练习
**练习1：**逢7过
朋友聚会的时候可能会玩一个游戏：逢7过
游戏规则:从任意一个数字开始报数，当你要报的数字是包含 7 或者是 7 的倍数时都要说： 过
需求：使用程序在控制台打印出 1 - 100 之间的满足逢 7 必过规则的数据
package Just.test;
public class Test1 {
public static void main(String[] args) {
int number = 0;
for(int i = 1;i <= 100;i++){
number++;
if(i % 7 ==0||i % 10 == 7||i / 10 ==7){
System.out.print( "过、");
if(number % 10 == 0){
System.out.println();
}
continue;
}
System.out.print(i + "、");
if(number % 10 == 0){
System.out.println();
}
}
}
}
运行结果：
1、2、3、4、5、6、过、8、9、10、
11、12、13、过、15、16、过、18、19、20、
过、22、23、24、25、26、过、过、29、30、
31、32、33、34、过、36、过、38、39、40、
41、过、43、44、45、46、过、48、过、50、
51、52、53、54、55、过、过、58、59、60、
61、62、过、64、65、66、过、68、69、过、
过、过、过、过、过、过、过、过、过、80、
81、82、83、过、85、86、过、88、89、90、
过、92、93、94、95、96、过、过、99、100、
**练习2：**求平方根
需求：键盘录入一个大于等于 2 的整数 x ，计算并返回 x 的平方根。
结果只保留整数部分，小数部分将被舍去
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
//键盘录入一个大于2的数
Scanner sc = new Scanner(System.in);
System.out.println("键盘录入大于 2 的数是：");
int number = sc.nextInt();
for(int i = 1;i <= number;i++){
if(i * i <= number&& (i +1)*(i + 1) > number){
System.out.println("输出" + number + "平方根的整数部分：");
System.out.println(i);
}
}
}
}
运行结果：
键盘录入大于 2 的数是：
20
输出20平方根的整数部分：
4
public class Test2 {
public static void main(String[] args) {
//键盘录入一个大于2的数
Scanner sc = new Scanner(System.in);
System.out.println("键盘录入大于 2 的数是：");
int number = sc.nextInt();
for(int i = 1;i <= number;i++){
if(i * i == number){
System.out.println("输出" + number + "平方根的整数部分：");
System.out.println(i);
break;
}
if(i * i > number){
System.out.println("输出" + number + "平方根的整数部分：");
System.out.println(i - 1);
break;
}
}
}
}
运行结果：
键盘录入大于 2 的数是：
20
输出20平方根的整数部分：
4
练习3: 求质数
需求: 键盘录入一个正整数 x ，判断该整数是否为一个质数。
质数，只有 1 和 它本身两个因数的数。
package Just.test;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//键盘录入一个数
Scanner sc = new Scanner(System.in);
System.out.println("输入一个整数: ");
int number = sc.nextInt();
//定义一个变量，表示标记，标记 number 是否为质数
//true:是一个质数
//false:不是一个质数
//最初认为 number 是一个质数
boolean flag = true;
for(int i = 2;i < number;i++) {
if(number % i == 0){
flag = false;
break;
}
}
if(flag){
System.out.println(number + "是一个质数");
}else{
System.out.println(number + "不是一个质数");
}
}
}
运行结果：
输入一个整数:
31
31是一个质数
运行结果：
输入一个整数:
25
25不是一个质数
优化后的代码：
思路：减少 for 循环的次数， a * b = c , 则 a 和 b 中必有一个数是 小于等于 c 平方根的
于是把 for循环中的 i < number 换成 i < number 的平方根，就可以减少 for循环的次数，从而提高效率，达到优化的目的。
**练习：**猜数字小游戏
需求：程序自动生成一个 1 ~ 100之间的随机数字，使用程序实现猜出这个数字是多少？
package Just.test;
import java.util.Random;
import java.util.Scanner;
public class Test4 {
public static void main(String[] args) {
//生成一个 1 ~ 100 之间的随机数
Random r = new Random();
int number = 1 + r.nextInt(100);
//键盘录入你所猜的数
Scanner sc = new Scanner(System.in);
//无限循环，当未猜中时，一直循环下去，不断猜测
while (true){
System.out.println("请输入你要猜的数字：");
int guessNumber = sc.nextInt();
if(guessNumber > number){
System.out.println("大了");
}else if(guessNumber < number){
System.out.println("小了");
}else{
System.out.println("中了");
//猜中后，跳出循环
break;
}
}
}
}
注意事项：
1、生成随机数的代码是不能写在循环的里面，否则每一次都会产生一个新的随机数
2、抽奖机制：保底
加一个计数器，当抽奖未抽中而达到保底次数时，直接输出 “ 抽中 ” ，跳出循环。
public class Test4 {
public static void main(String[] args) {
.......
int count = 0
while (true){
......
count++;
......
if(count == n){
System.out.println("中了");
break;
}
/*if(guessNumber > number){
System.out.println("大了");
}else if(guessNumber < number){
System.out.println("小了");
}else{
System.out.println("中了");
//猜中后，跳出循环
break;
}*/
}
}
}
获取随机数
Java 已经帮我们写好一个类叫 Random , 这个类就可以生成一个随机数。
使用步骤：
1、导包
import java.util.Random;
导包的动作必须出现在类定义的上边
2、创建对象
Random r = new Random();
上面这个格式里面，只有 r 是变量名，可以变，其他的都不允许变。
3、生成随机数
int number = r.nextInt(随机数的范围)；
上面这个格式里面，number 是变量名，可以变
注意事项：随机数范围
在小括号中书写的是随机数的范围，这个范围是从零开始的，到这个数的 - 1 结束。
口诀：包头不包尾，包左不包右。
用来生成任意数到任意数之间的随机数：
- 让这个范围头尾都减去一个值，让这个数范围从 0 开始
- 尾巴 + 1
- 最终的结果，再加上第一步减去的值
例如：生成 7 ~ 15 之间的随机数
1、- 7，变成 0 ~ 8
2、尾巴 + 1 , 变成 0 ~ 9
3、加上 1、 减去的 7 ，变成 7 + （ 0 ~ 9）
编程实现：
Random r = new Random();
int number = 7 + r.nextInt(9);
System.out.println(number);
数组
数组介绍
**数组：**数组指的是一种容器，可以用来存储同种数据类型的多个值
-
数组容器在存储数据的时候，需要结合隐式转换考虑。
例如： int 类型的数组容器可以存储（ byte、short、int ) , 不可以存储( boolean、double)
例如： double 类型的数组容器可以存储（ byte、short、int、long、float、double )
- 建议：容器的类型，和存储的数据类型保持一致
数组的定义：
格式一： 数据类型 [] 数组名 （常用）
范例： int [] array
格式二： 数据类型 数组名 []
范例： int array []
数组的初始化
数组的静态初始化
初始化：就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程
简化格式：数据类型 [] 数组名 = {元素1，元素2，元素3，…};
非简化格式：数据类型 [] 数组名 = new 数据类型 [] {元素1，元素2，元素3，…};
- 范例：int [] array = {11,22,33};
- 范例：double [] array2 = {11.1, 22.2, 33.3};
注意事项：
1、数组中元素的个数就是数组的长度
2、数组一旦创建完毕，其长度就固定了
package Just.arraydemo;
public class ArrayDemo {
public static void main(String[] args) {
//定义数组存储5个学生的年龄
int[] array1= {12,13,14,16,17};
//定义数组存储3个学生的姓名
String[] array2 = {"张三","李四","王五"};
//定义数组存储4个学生的身高
double[] array3 = {187.3,178.5,179.5,176.8};
}
}
数组的地址值和元素访问
数组的地址值
表示数组在内存中的位置
数组元素访问
格式： 数组名 [索引];
索引：
- 索引：也叫做下标，角标
- 索引的特点：从 0 开始，逐个 + 1增长，连续不间断，到数组的长度减一
存储数组元素
格式：数组名[索引] = 具体数据/变量；
注意：一旦覆盖之后，原来的数据就不存在了
package Just.arraydemo;
public class ArrayDemo2 {
public static void main(String[] args) {
//利用索引对数组的元素进行访问
int[] arr = {1,2,3,4,5};
int number = arr[0];
System.out.println("输出数组中索引0对应的元素：");
System.out.println(number);
//获取数组中1索引对应的数据，并直接打印出来
System.out.println("输出数组中索引1对应的元素：");
System.out.println(arr[1]);
//把数据存储到数组当中
arr[1] = 12;
System.out.println("输出覆盖后数组中索引1对应的元素：");
System.out.println(arr[1]);
}
}
运行结果：
输出数组中索引0对应的元素：
1
输出数组中索引1对应的元素：
2
输出覆盖后数组中索引1对应的元素：
12
数组的遍历
**数组遍历：**将数组中所有内容取出来，取出来之后可以（打印、求和、判断）
**注意：**遍历指的是取出数据的过程，不要局限的理解为，遍历就是打印
在 Java 当中，关于数组的一个长度属性，length
调用方式：数组名.length
扩展：
idea 提供的，自动的快速生成数组的遍历方式
数组名.fori
package Just.arraydemo;
public class ArrayDemo4 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
/*for(int i = 0;i < 5;i++){
System.out.println(arr[i]);
}*/
System.out.println("输出正序：");
for(int i = 0;i < arr.length;i++){
System.out.print(arr[i]);
}
System.out.println();
System.out.println("输出逆序：");
for (int i = arr.length - 1; i >= 0; i--) {
System.out.print(arr[i]);
}
}
}
运行结果：
输出正序：
12345
输出逆序：
54321
**练习：**遍历数组并求和
定义一个数组，存储 1，2，3，4，5
遍历数组得到每一个元素，求数据里面所有的数据和
package Just.test;
public class Test5 {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
//求数组的和
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum = sum + arr[i];
}
System.out.println("输出数组中元素的和为：");
System.out.println(sum);
}
}
运行结果：
输出数组中元素的和为：
15
**练习：**统计个数
定义一个数组，存储 1，2，3，4 ，5，6，7，8，9，10
遍历数组得到每一个元素，统计数组里面一共有多少个能被 3 整除的数字
package Just.test;
public class Test6 {
public static void main(String[] args) {
//定义数组
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//定义计数器
int number = 0;
//循环遍历数组
for (int i = 0; i < arr.length; i++) {
if(arr[i] % 3 ==0){
number++;
}
}
System.out.println("输出数组里面能被3整除的元素个数：");
System.out.println(number);
}
运行结果：
输出数组里面能被3整除的元素个数：
3
**练习：**变化数据
定义一个数组，存储 1，2，3，4，5，6，7，8，9，10
遍历数组得到每一个元素。
要求：
1、如果是奇数，则将当前数字扩大两倍
2、如果是偶数，则将当前数字变成二分之一
package Just.test;
public class Test7 {
public static void main(String[] args) {
//定义数组
int[] arr = {1,2,3,4,5,6,7,8,9,10};
//定义换行计数器
int cout = 0;
//循环遍历
for (int i = 0; i < arr.length; i++) {
if(arr[i] % 2 == 0){
System.out.print(arr[i]/2 + "、");
}else{
System.out.print(arr[i]*2 + "、");
}
cout++;
if(cout % 5 == 0){
System.out.println();
}
}
}
}
运行结果：
2、1、6、2、10、
3、14、4、18、5、
数组的动态初始化
**动态初始化：**初始化时只指定数组长度，由系统为数组分配初始值。
格式：数据类型 [] 数组名 = new 数据类型 [数组长度]；
范例：int [] arr = new int [3];
package Just.arraydemo;
public class ArrayDemo3 {
public static void main(String[] args) {
//定义一个数组，用来存储班级中50个学生的姓名
String[] arr = new String[50];
//添加学生
arr[0] = "张三";
arr[1] = "李四";
//获取
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
运行结果：
张三
李四
null
数组默认初始化值的规律
- 整数类型：默认初始化值 0
- 小数类型：默认初始化值 0.0
- 字符类型：默认初始化值’/u0000’ 也就是 ’ 空格 ’
- 布尔类型：默认初始化值 false
- 引用数据类型：默认初始化值 null
静态、动态初始化区别
动态初始化：手动指定数组长度，由系统给出默认初始化值。
- 只明确元素个数，不明确具体数值，推荐使用动态初始化
举例：使用数组容器来存储键盘录入的5个整数。
int[] arr = {?,?,?,?,?,?,?};
int[] arr = new int[5];
静态初始化：手动指定数组元素，系统会根据元素个数，计算出数组的长度。
- 需求中已经明确要操作的数据，直接静态初始化即可。
举例：将全班的学生成绩存入数组中 11，33，45
int[] arr = {11,33,45};
索引越界异常：
原因：访问了不存在的索引
避免：索引范围
最小索引：0
最大索引：数组长度 - 1
练习
求最值
需求：已知数组元素为{33，5，22，44，55}
请找出数组中最大值并打印在控制台
package Just.test;
public class Test8 {
public static void main(String[] args) {
//定义数组
int [] arr = {33,5,22,44,55};
//定义变量记录最大值，并临时认为arr[0]为数据最大值
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if(arr[i] > max){
max = arr[i];
}
}
//输出最大值
System.out.println("输出数组中的最大元素值：");
System.out.println(max);
}
}
运行结果：
输出数组中的最大元素值：
55
注意事项：
-
max 的初始值不能默认为 0
-
max 的初始化值一定是数组中的元素
-
当 max 的初始值为 arr[0] 时，for 循环的 i 可以从 1 开始
遍历数组并求和
**需求：**生成 10 个 1 ~ 100 之间的随机数存入数组。
1）求出所有数据的和
2）求所有数据的平均数
3）统计有多少个数据比平均值小
package Just.test;
import java.util.Random;
public class Test9 {
public static void main(String[] args) {
//随机生成 10 个，1 ~ 100 之间的随机数存入数组
Random r = new Random();
//定义数组
int [] arr = new int [10];
for (int i = 0; i < arr.length; i++) {
arr[i] = 1 + r.nextInt(100);
}
//定义计数器
int number = 0;
//输出随机生成的10个数
System.out.println("输出随机生成的10个数：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "、");
number++;
if(number % 5 == 0){
System.out.println();
}
}
//定义10个数的和的变量
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum = sum + arr[i];
}
//输出随机生成的10个数的和
System.out.println("随机生成的10个数的和：");
System.out.println(sum);
System.out.println();
//定义平均数变量
double average = (double)sum / arr.length;
//输出10个数的平均数
System.out.println("输出10个数的平均数：");
System.out.println(average);
//定义计数器
int count = 0;
for (int i = 0; i < arr.length; i++) {
if(arr[i] < average){
count++;
}
}
//输出比平均数小的数据个数
System.out.println("输出比平均数小的数据个数：");
System.out.println(count);
}
}
运行结果：
输出随机生成的10个数：
10、47、36、62、28、
89、31、93、38、12、
随机生成的10个数的和：
446
输出10个数的平均数：
44.6
输出比平均数小的数据个数：
6
交换数组中的数据
需求：定义一个数组，存入 1，2，3，4，5。按照要求交换索引对应的元素。
交换前：1，2，3，4，5
交换后：5，4，3，2，1
package Just.test;
public class Test10 {
public static void main(String[] args) {
//定义数组
int[] arr = {1,2,3,4,5};
//for循环遍历数组
System.out.println("交换前：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "、");
}
System.out.println();
//按照要求进行交换
for (int i = 0,j = arr.length - 1; i < j; i++,j--) {
int temp;
temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//for循环遍历
System.out.println("交换后：");
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "、");
}
}
}
运行结果：
交换前：
1、2、3、4、5、
交换后：
5、4、3、2、1、
打乱数组中的数据
**需求：**定义一个数组，存入 1 ~ 5。要求打乱数组中的所有数据的顺序。
package Just.test;
import java.util.Random;
public class Test11 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {1,2,3,4,5};
//循环遍历数组
for (int i = 0; i < arr.length; i++) {
//获取随机索引
Random r = new Random();
int randomIndex = r.nextInt(arr.length);
//定义第三方变量
int temp = arr[i];
arr[i] = arr[randomIndex];
arr[randomIndex] = temp;
}
//for循环遍历输出
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "、");
}
}
}
运行结果：
2、1、5、4、3、
1、3、4、5、2、
数组的内存图
Java 内存分配
- 栈：方法运行时使用的内存，比如 main 方法运行，进入方法栈中执行
- 堆：存储对象或者数组，new 来创建的，都存储在堆内存
- 方法区：存储可以运行的 class 文件
- 本地方法栈：JVM 在使用操作系统功能的时候使用，和我们开发无关
- 寄存器：给 CPU使用，和我们开发无关
注意：变量存储的是数值
数组的内存分配
注意：数组存储的是地址
总结：
- 只要是 new 出来的一定是在堆里面开辟了一个小空间，而且开辟出的空间是有地址值的
- 如果 new 了多次，那么在堆里面有多个小空间，每个小空间都有各自的数据
两个数组指向同一个空间的内存图
**总结：**当两个数组指向同一个小空间时，其中一个数组对小空间中的值发生了改变，那么其他数组再次访问的时候是修改之后的结果了。
二维数组
二维数组：数组中存数组
二维数组的应用场景：当我们需要把数据分组管理的时候，就需要用到二维数组
二维数组的初始化
1、静态初始化
格式：
数据类型 [][] 数组名 = new 数据类型[][] {{元素1，元素2}，{元素1，元素2}}；
范例：
int [][] arr = new int[][]{{11,22},{33,44}};
简化格式
数据类型[][] 数组名 = {{元素1，元素2}，{元素1，元素2}}；
范例：
int[][] arr = {{11,22},{33,44}};
int arr[][] = {{11,22},{33,44}};
package Just.twodimensionarr;
public class TwoDimensionDemo1 {
public static void main(String[] args) {
//1、二维数组静态初始化格式
//数据类型[][] 数组名 = new 数据类型[][] {{元素1，元素2}，{元素1，元素2}}；
int [][] arr1 = new int[][] {{1,2,3},{4,5,6,7,8}};
int [][] arr2 = {{1,2,3},{4,5,6,7,8}};
//书写二维数组，建议把每一个一维数组单独写成一行
//注意：每一个一维数组其实是二维数组中的元素，所以每一个一维数组之间需要用" , "隔开。最后一个一维数组后面不需要加逗号
int [][] arr3 = {
{1,2,3},
{4,5,6,7,8}
};
//2、获取元素
/*
arr[i][j]
arr:二维数组
i:二维数组的索引，获取出来的是里面的一维数组
j:表示一维数组中的索引，获取出来的就是真正的元素
*/
System.out.println(arr3[0]);//表示获取二维数组中的第一个一维数组(的地址值)
//arr3[0]:二维数组中的第一个一维数组
//arr3[0][0]:获取第一个一维数组中的0索引的元素
System.out.println(arr3[0][0]);
//arr3[1]:二维数组中的第二个一维数组
//arr3[1][4]:获取第二个一维数组中的4索引元素
System.out.println(arr3[1][4]);
//遍历二维数组
//方法：先得到一维数组，再遍历一维数组获取元素
//外循环：遍历二维数组，得到里面的每一个一维数组
for (int i = 0; i < arr3.length; i++) {
//i:表示二维数组中的每一个索引
//arr3[i]:表示二维数组中的每一个元素，即一维数组
//内循环：遍历一维数组，得到里面的，每一个元素
for (int j = 0; j < arr3[i].length; j++) {
System.out.print(arr3[i][j] + " ");
}
//内循环结束后，表示一个一维数组就遍历完毕了，换行
System.out.println();
}
}
}
运行结果：
[I@1d251891
1
8
1 2 3
4 5 6 7 8
2、动态初始化
格式：
数据类型 [][] 数组名 = new 数据类型[m][n];
m：表示这个二维数组，可以存放多少个一维数组
n：表示每一个一维数组，可以存放多少个元素
范例：
int [][] arr = new int[2][3];
该数组可以存放2个一维数组，每个一维数组可以存放3个int 类型元素
package Just.twodimensionarr;
public class TwoDimensionDemo2 {
public static void main(String[] args) {
//1、利用动态初始化创建创建二维数组
//3:表示二维数组长度为3，可以装3个一维数组
//5：表示每一个一维数组的长度都是5，可以装5个 int 类型的元素
int [][] arr = new int[3][5];
//给二维数组赋值元素
arr[0][0] = 10;
arr[2][4] = 23;
arr[0][3] = 45;
arr[1][2] = 21;
//遍历二维数组
//外循环：遍历二维数组获取里面的每一个一维数组
//内循环；遍历一维数组获取每一个元素
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + "、");
}
//遍历完一个一维数组后换行
System.out.println();
}
}
}
运行结果：
10、0、0、45、0、
0、0、21、0、0、
0、0、0、0、23、
二维数组的内存图
特殊情况一
自己创建一维数组，一维数组的长度可以不同
特殊情况二
练习：二维数组的练习
某商城每一个季度的营业额如下：单位（万元）
第一季度：22，66，44
第二季度：77，33，88
第三季度：25，45，65
第四季度：11，66，99
要求计算出每一季度的总的营业额和全年的营业额
package Just.twodimensionarr;
public class Test {
public static void main(String[] args) {
//定义二维数组
int[][] arr ={
{22,66,44},
{77,33,88},
{25,45,65},
{11,66,99}
};
int yearSum = 0;
for (int i = 0; i < arr.length; i++) {
int sum = getSum(arr[i]);//arr[i]即为 对应一维数组的 数组名
yearSum = yearSum + sum;
System.out.println("第" +(i + 1) + "个季度的总营业额为：" + sum);
}
System.out.println("四季度总的营业额为：" + yearSum);
}
//定义一个方法，用于计算每一个季度的营业额
public static int getSum(int[] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum = sum + arr[i];
}
return sum;
}
}
运行结果：
第1个季度的总营业额为：132
第2个季度的总营业额为：198
第3个季度的总营业额为：135
第4个季度的总营业额为：176
四季度总的营业额为：641
注意：
对于任意二维数组：
数据类型 [][] 数组名 = .......
其中对应的一维数组名为：数组名[i]
方法
方法介绍
1、什么是方法？
方法 (method) 是程序中最小的执行单元
2、实际开发中，什么时候用到方法？
重复的代码、具有独立功能的代码可以抽取到方法中。
3、实际开发中，方法有什么好处？
- 可以提高代码的复用性
- 可以提高代码的可维护性
方法的格式
方法定义
把一些代码打包在一起，该过程称为方法定义
方法的定义格式：
public static 返回值类型 方法名 (参数){
方法体；
return 返回值；
}
方法调用
方法定义后不是直接运行的，需要手动调用才能执行，该过程称为方法调用
1、最简单的方法定义和调用
方法 定义
格式：
public static void 方法名(){
方法体(就是打包起来的代码)；
}
范例：
public static void playGame(){
打印语句；
}
方法 调用
格式：
格式：
方法名();
范例：
playGame();
注意：****方法必须先定义后调用，否则程序将报错
package Just.methoddemo;
public class MethodDemo1 {
public static void main(String[] args) {
//调用方法
playGame();
}
//定义一个方法
public static void playGame(){
System.out.println("选人物");
System.out.println("准备开局");
System.out.println("对线");
System.out.println("崩盘");
System.out.println("骂队友");
System.out.println("送人头");
System.out.println("GG");
}
}
运行结果：
选人物
准备开局
对线
崩盘
骂队友
送人头
GG
练习：展示女朋友的信息
需求：定义一个方法，在方法内部打印你女朋友的所有信息
package Just.methoddemo;
public class MethodDemo2 {
public static void main(String[] args) {
//函数调用
printGFInformation();
}
//定义方法
public static void printGFInformation(){
System.out.println("鑫鑫");
System.out.println("萌妹子");
System.out.println("18岁");
}
}
运行结果：
鑫鑫
萌妹子
18岁
练习：人肉计算器
需求：定义一个方法，在方法内部定义两个变量。
求出它们的和并进行打印。
package Just.methoddemo;
public class MethodDemo3 {
public static void main(String[] args) {
getSum();
}
//定义方法
public static void getSum(){
int num1 = 10;
int num2 = 20;
//求和
int result = num1 + num2;
System.out.println("输出两个数的和：");
System.out.println(result);
}
}
运行结果：
输出两个数的和：
30
2、带参数的方法定义和调用
单个参数 定义：
格式：
public static void 方法名 (参数){
......
}
范例：
public static void method(int number){
......
}
多个参数 定义：
格式：
public static void 方法名(参数1，参数2，......){
......
}
范例：
public static void getSum(int number1,int number2,......){
......
}
带参数方法 调用：
单个参数
单个参数：方法名(参数)；
范例1：method(10);
范例2：method(变量)；
多个参数
多个参数：方法名(参数1，参数2，......);
范例1：getSum(10,20);
范例2：getSum(变量1，变量2)；
注意：
- 方法调用时，参数的数量与类型必须与方法中定义小括号里面的变量一 一对应，否则程序将报错
package Just.methoddemo;
import java.util.Scanner;
public class MethodDemo4 {
public static void main(String[] args) {
//输入需要相加的数
System.out.println("输入需要相加的数：");
Scanner sc = new Scanner(System.in);
int number1 = sc.nextInt();
int number2 = sc.nextInt();
System.out.println("输出相加的结果为：");
getSum(number1,number2);
}
//定义求和方法
public static void getSum(int number1,int number2){
int result = number1 + number2;
System.out.println(result);
}
}
运行结果：
输入需要相加的数：
12
15
输出相加的结果为：
27
形参和实参
形参：全称形式参数，是指方法定义中的参数
**实参：**全称实际参数，方法调用中的参数
注意：方法调用时，形参和实参必须一 一对应，否则程序将报错
方法定义小技巧：
1、我要干什么？ 方法体
2、我干这件事情需要什么才能完成？ 形参
练习：
人肉计算机1
需求：定义一个方法，求长方形的周长，将结果在方法中进行打印。
package Just.test;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//键盘录入长方形的长、宽
Scanner sc = new Scanner(System.in);
System.out.println("长方形的长为：");
double length = sc.nextDouble();
System.out.println("长方形的宽为：");
double width = sc.nextDouble();
System.out.println("输出长方形的周长为：");
getLength(length,width);
}
//定义求长方形周长的函数
public static void getLength(double length,double width){
double result = (length + width)*2;
System.out.println(result);
}
}
运行结果为：
长方形的长为：
12
长方形的宽为：
8
输出长方形的周长为：
40.0
人肉计算机2
需求：定义一个方法，求圆的面积，将结果在方法中进行打印。
package Just.test;
import java.util.Scanner;
public class Test2 {
public static void main(String[] args) {
//输入圆的半径
Scanner sc = new Scanner(System.in);
System.out.println("输入圆的半径：");
double radius = sc.nextDouble();
System.out.println("输出圆的面积：");
getArea(radius);
}
//定义函数，求圆的面积 ，半径的平方 * Π
public static void getArea(double radius){
double result = radius * radius *3.14;
System.out.println(result);
}
}
运行结果：
输入圆的半径：
1
输出圆的面积：
3.14
3、带返回值方法的定义和调用
方法的返回值就是方法运行的最总结果
- 如果在调用处要根据方法的结果，去编写另外一段代码逻辑
- 为了在调用处拿到方法的产生结果，就需要定义带有返回值的方法
定义：
格式
public static 返回值类型 方法名(参数){
方法体；
return 返回值；
}
范例：
public static int getSum(int a ,int b){
int c = a + b;
return c;
}
调用：
(1) 直接调用
方法名(实参)；
(2) 赋值调用
返回值类型 变量名 = 方法名(实参)；
(3) 输出调用
System.out.println(方法名(实参))；
练习：
人肉计算机
需求：定义一个方法，求一家商场每个季度的营业额。
根据方法结果再计算出全年营业额。
package Just.methoddemo;
public class MethodDemo5 {
public static void main(String[] args) {
//计算第一季度的营业额
double sum1 = getSum(12.2,13.4,11.5);
//计算第二季度的营业额
double sum2 = getSum(11.2,14.4,12.7);
//计算第三季度的营业额
double sum3 = getSum(13.2,10.4,13.5);
//计算第四季度的营业额
double sum4 = getSum(12.6,13.4,14.5);
//计算全年总营业额
double sum = sum1 + sum2 + sum3 + sum4;
System.out.println("输出全年的总营业额：");
System.out.println(sum);
}
//定义函数，求每季度的营业额
public static double getSum(double number1,double number2,double number3){
double result = number1 + number2 + number3;
return result;
}
}
运行结果：
输出全年的总营业额：
153.0
注意：
1、什么时候用到有返回值的方法？
在调用处要根据方法的结果，去编写另外一段代码
练习：
需求：定义方法，比较两个长方形的面积。
package Just.test;
import java.util.Scanner;
public class Test3 {
public static void main(String[] args) {
//输入量长方形的长、宽
Scanner sr = new Scanner(System.in);
//输入长方形1的长、宽
System.out.println("输入长方形1的长、宽");
double length1 = sr.nextDouble();
double width1 = sr.nextDouble();
double area1 = getArea(length1,width1);
//输入长方形2的长、宽
System.out.println("输入长方形2的长、宽");
double length2 = sr.nextDouble();
double width2 = sr.nextDouble();
double area2 = getArea(length2,width2);
System.out.println();
//输出两长方形的面积
System.out.println("输出两长方形的面积：");
System.out.println(area1);
System.out.println(area2);
System.out.println();
//把两长方形的面积进行比较
System.out.println("输出两长方形中的面积较大者：");
compareArea(area1,area2);
}
//定义方法，计算长方形的面积
public static double getArea(double length,double width){
double area = length * width;
return area;
}
//定义方法，比较长方形的面积
public static void compareArea(double area1,double area2){
if(area1 > area2){
System.out.println("长方形1");
}else{
System.out.println("长方形2");
}
}
}
运行结果：
输入长方形1的长、宽
2.5
1.2
输入长方形2的长、宽
2.8
0.8
输出两长方形的面积：
3.0
2.2399999999999998
输出两长方形中的面积较大者：
长方形1
4、方法的完整定义格式
带返回值方法定义：
格式
public static 返回值类型 方法名 (参数){
方法体；
return 返回值；
}
方法的注意事项：
-
方法不调用就不执行
-
方法与方法之间是平级关系，不能互相嵌套定义
-
方法的编写顺序和执行顺序无关
-
方法的返回值类型为 void ,表示该方法没有返回值，
没有返回值的方法可以省略 return 语句不写。
如果要编写 return ，后面不能跟具体的数据。
-
return 语句下面，不能编写代码，因为永远执行不到，属于无效的代码
方法的重载
方法重载：
- 在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能。
- 每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系。
**简单记：**同一个类中，方法名相同，参数不同的方法。与返回值无关。
参数不同：个数不同、类型不同、顺序不同(不建议使用)
Java虚拟机会通过参数的不同来区分同名的方法
**练习：**方法重载
需求：使用方法重载的思想，设计比较两个整数是否相同的方法。
需求：兼容全整数类型(byte ,short ,int ,long)
package Just.test;
public class Test4 {
public static void main(String[] args) {
System.out.println("输出两个数中的较大值：");
compare((long)12,(long)15);
compare(45,48);
compare((short)23,(short)43);
compare((byte)78,(byte)90);
}
//定义方法判断两个数的大小
public static void compare(long number1,long number2){
System.out.println("long");
if(number1 > number2){
System.out.println(number1);
}else {
System.out.println(number2);
}
}
public static void compare(int number1,int number2){
System.out.println("int");
if(number1 > number2){
System.out.println(number1);
}else {
System.out.println(number2);
}
}
public static void compare(short number1,short number2){
System.out.println("short");
if(number1 > number2){
System.out.println(number1);
}else {
System.out.println(number2);
}
}
public static void compare(byte number1,byte number2){
System.out.println("byte");
if(number1 > number2){
System.out.println(number1);
}else {
System.out.println(number2);
}
}
}
运行结果：
输出两个数中的较大值：
long
15
int
48
short
43
byte
90
**练习：**数组遍历
需求：设计一个方法用于数组遍历，要求遍历的结果是在一行上的。例如：[11, 22, 33, 44, 55 ]
package Just.test;
public class Test5 {
public static void main(String[] args) {
//定义数组
int[] arr = {11,22,33,44,55};
System.out.println("打印数组：");
printArr(arr);
}
public static void printArr(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i < arr.length - 1){
System.out.print(arr[i] + ",");
}else{
System.out.print(arr[i]);
}
}
System.out.println("]");
}
}
运行结果：
打印数组：
[11，22，33，44，55]
**练习：**数组最大值
需求：设计一个方法求数组的最大值，并将最大值返回
package Just.test;
public class Test6 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {12,34,56,78,99};
//输出数组中的最大值
System.out.println("输出数组中的最大值:");
System.out.println(getMax(arr));
}
//设计函数求数组的最大值，并将最大值返回
public static int getMax(int[] arr){
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if(max < arr[i]){
max = arr[i];
}
}
return max;
}
}
运行结果：
输出数组中的最大值:
99
**练习：**判断是否存在
需求：定义一个方法判断数组中的某个数是否存在，将结果返回个调用处
import java.util.Scanner;
public class Test7 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {12,34,56,78,90,58,39,42,93,63,81};
//输入待判定的数
Scanner sr = new Scanner(System.in);
System.out.println("输入待判定的数:");
int number = sr.nextInt();
System.out.println(contains(number,arr));
}
//定义一个方法，判断数组中的数是否存在，将结果返回给调用处
public static boolean contains(int number,int[] arr){
for (int i = 0; i < arr.length; i++) {
if(number == arr[i]) {
return true;
}
}
return false;
}
}
运行结果：
输入待判定的数:
90
true
**ruturn 😗*其实跟循环没有什么关系，跟方法有关的，表示 1 结束循环、2 返回结果
如果==方法执行到了 return,那么整个方法全部结束==，里面的循环也会随之结束了。
练习：
需求：定义一个方法 copyOfRange(int[] arr,int from,int to)
功能：将数组 arr 中从索引 from(包含 from) 开始。
到索引 to 结束(不包含 to)的元素复制到数组中，
将新数组返回
package Just.test;
public class Test8 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {1,2,3,4,5,6,7,8,9};
int[] newArr = copyOfRange(arr,2, 7) ;
System.out.println("打印数组：");
printArr(newArr);
}
//定义一个函数，返回数组 int[]
public static int[] copyOfRange(int[] arr,int from,int to){
//定义新数组
int[] newArr = new int[to - from];
//定义新数组索引
int index = 0;
for(int i = from;i < to;i++){
//通过 for循环把数组arr 中的from到to-1上对应元素直接拷贝到newArr中
newArr[index] = arr[i];
index++;
}
return newArr;
}
//定义一个函数，打印数组
public static void printArr(int[] arr){
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if(i < arr.length - 1){
System.out.print(arr[i] + ",");
}else{
System.out.print(arr[i]);
}
}
System.out.println("]");
}
}
运行结果：
打印数组：
[3,4,5,6,7]
方法的内存
1、方法调用的基本内存原理
注意：方法执行完，回到调用处
栈内存的特点：先进栈的，先出栈
2、方法传递基本数据类型的内存原理
基本数据类型
举例：
总结：传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值
形参不影响实际参数
3、方法传递引用数据类型的内存原理
引用数据类型
举例：
总结：传递引用数据类型时，传递的是地址值，形参的改变，影响实际参数的值
形参影响实际参数
4、总结
面向对象
面向对象介绍：
- 面向：拿、找
- 对象：能干活的东西
- 面向对象的编程：拿东西过来做对应的事情
面向对象的重点学习什么？
1、学习获取已有对象并使用
2、学习如何自己设计对象并使用——>面向对象的语法
设计对象并使用
类和对象
类(设计图）：是对象共同特征的描述；
对象： 是真实存在的具体实例
在 Java 中，必须先设计类，才能获得对象。
如何定义类
public class 类名 {
1、成员变量（代表属性，一般是名词）（只定义，不给值）
2、成员方法（代表行为，一般是动词）(定义方法时，不要 static)
3、构造器（后面学习）
4、代码块（后面学习）
5、代码块（后面学习）
}
定义一个手机类：
public class Phone{
//属性（成员变量）
String brand;
double price;
//行为（方法）
public void call(){
}
public void playGame(){
}
}
如何创建类的对象
类名 对象名 = new 类名( );
举例：定义一个手机对象
Phone p = new Phone();
如何使用对象
- 访问属性：对象名.成员变量
- 访问行为：对象名.方法名(…)
package Just.test;
public class PhoneTest {
public static void main(String[] args) {
//创建手机的对象 类名 对象名 = new 类名();
Phone p = new Phone();
//给手机赋值
p.brand = "小米";
p.price = 1999.9;
//获取手机对象中的值
System.out.println(p.brand);
System.out.println(p.price);
//调用手机中的方法
p.call();
p.playGame();
//创建第二个手机对象
Phone p2 = new Phone();
p2.brand = "苹果";
p2.price = 8999.9;
System.out.println(p2.brand);
System.out.println(p2.price);
p2.call();
p2.playGame();
}
}
=================================================
package Just.test;
public class Phone {
//属性
String brand;//手机品牌
double price;//手机价格
//行为
public void call(){
System.out.println("手机在打电话");
}
public void playGame(){
System.out.println("手机在打游戏");
}
}
运行结果：
小米
1999.9
手机在打电话
手机在打游戏
苹果
8999.9
手机在打电话
手机在打游戏
类的种类及注意事项
| 类的种类 | 功能 | 举例 |
|---|---|---|
| Javabean 类 | 用来描述一类事物的类 | 比如，Student, Teacher, Dog, Cat 等 |
| 测试类 | 编写 main 方法的类，我们可以在测试类中创建 Javabean类的对象并进行赋值调用 | |
| 工具类 | 帮助我们做一些事情的，但是不描述任何事情的类 |
Javabean 类
格式：
public class 类名{
成员变量 (代表属性)
成员方法(代表行为)
}
举例：
public class Student {
//属性(成员变量)
String name;
double height;
//行为(方法)
public void study{
}
public void sleep{
}
}
-
类名首字母建议大写，需要见名知意，驼峰模式
-
一个 Java 文件可以定义多个 class 类，且只能一个类是 public 修饰，而且 public 修饰的类名必须成为代码文件名。
实际开发中建议还是一个文件定义一个 class 类
-
成员变量的完整定义格式是：修饰符 数据类型 变量名称 = 初始化值；，一般无需指定初始化值，存在默认值。
-
数据类型 明细 默认 基本类型 byte、short、int、long 0 基本类型 float、double 0.0 基本类型 boolean false 引用类型 类、接口、数组、String null
工具类
工具类书写规则：
-
类名见名知意
-
私有化构造方法
public class ArrUtil{
//私有构造方法
private ArrUtil(){}
构造方法一旦私有，在外界就无法创建这个类的对象。
由于测试类不描述任何事物，所以创建其对象也毫无意义。
- 方法定义为静态
public class ArrUtil{
//私有构造方法
private ArrUtil(){}
//方法定义为静态
public static int getMax(...){...}
public static int getMin(...){...}
public static int getSum(...){...}
public static int getAvg(...){...}
}
练习：女朋友类
编写女朋友类，创建女朋友类的对象
给女朋友的属性赋值并调用女朋友类中的方法。
自己思考，女朋友类中有哪些属性，有哪些行为？
package Just.test1;
public class GirlFriend {
//属性(成员变量）
String name;
int age;
String gender;
//行为（方法）
public void sleep(){
System.out.println("女朋友在睡觉");
}
public void eat(){
System.out.println("女朋友在吃饭");
}
}
======================================================
package Just.test1;
public class GirlFriendTest {
public static void main(String[] args) {
//创建女朋友的对象
GirlFriend gf1 = new GirlFriend();
gf1.name = "鑫鑫";
gf1.age = 18;
gf1.gender = "萌妹子";
System.out.println(gf1.name);
System.out.println(gf1.age);
System.out.println(gf1.gender);
gf1.eat();
gf1.sleep();
System.out.println("=================");
GirlFriend gf2 = new GirlFriend();
gf2.name = "肉墩";
gf2.age = 20;
gf2.gender = "萌妹子";
System.out.println(gf2.name);
System.out.println(gf2.age);
System.out.println(gf2.gender);
gf2.sleep();
gf2.eat();
}
}
运行结果：
鑫鑫
18
萌妹子
女朋友在吃饭
女朋友在睡觉
=================
肉墩
20
萌妹子
女朋友在睡觉
女朋友在吃饭
开发中类的设计
名词提炼法：找属性(成员变量)
1、看有几类事物，每一类事物定义成一个类
2、名词提炼法：找属性(成员变量)
3、操作（行为），定义成方法
扫一扫
5809
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
