JAVA学习笔记-01（java基础阶段）

程序员 DELTA

已于 2023-02-21 20:52:03 修改

阅读量227

点赞数

分类专栏： Java 文章标签： java 学习 jvm

于 2023-01-12 23:42:19 首次发布

本文链接：https://blog.csdn.net/weixin_42482333/article/details/128638440

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1. 前言

1.1 Java的简介

首先什么是java？java是一门编程语言，就像我们现实生活中的语言一样，有英语、国语、俄语等等……我们要想和计算机进行沟通并且利用计算机完成某些程序功能，就必须学习编程语言，而java便是编程语言之一。
那么，我们为什么要学习Java而不学其它的编程语言呢？这就不得不提及java的各种特点以及它的优势了，在java1996年第一次出现在大众的视野中时，它便引起了大众的关注，在所有的程序设计语言中，Java是第一个也是唯一一个在National Public Radio上占用了10分钟时间进行介绍的程序设计语言，并且还得到了100000000美元的风险投资基金。java发布后，java的设计者编写了一个颇有影响力的白皮书，来解释设计初衷及完成的情况，他们还发布了一个简短的摘要。这个摘要按以下11个关键术语进行组织：

1.2 Java的跨平台

为什么说java跨平台是优势之一呢，以C语言为例子，以前我们开发一个C语言程序，需要分Windows版和其它平台的版本，各平台是不兼容的，这大大增加了开发的成本和难度，现在Java对这一问题进行了解决，只需要写一份代码，便可以在不同的平台上运行！
说完了跨平台，我们就不得不说跨平台的本质和核心，主角便是JVM（java虚拟机），java为每个平台提供了不同版本的JVM，因此在不同的平台只需装对应的JVM就可以完成代码的运行，也就实现了一次编译，到处使用！

1.3 一次编译，到处使用

java跨平台总结来说就是一次编译，到处使用，那么具体怎么理解呢？首先我们知道，我们要用计算机设计程序，就要使用编程语言，那么计算机真的能看懂我们写的代码吗？其实不然，计算机是非常单纯的，单纯到只认识0和1，因此，在我们写完代码生成.java文件后，需要进行编译，java使用的是javac的编译方式，编译完成后，会生成.class文件，该文件是只有计算机才能看懂的文件，此时编译完成后的class文件只需交给对应平台的JVM便可以完成运行，也就实现了一次编译，到处使用！

1.4 必备开发工具

1.4.1 JDK

说明：JDK是java的开发工具包(Java Development Kit)，是开发java必备的软件，它由几部分组成：

JVM（虚拟机）

加载并运行.class字节码文件

JRE（java运行环境）

除了包含JVM以外还包含了运行java程序所必须的环境
JRE = JVM+java系统类库(小零件)

JDK：java开发工具包

除了包含JRE以外还包含了开发java程序所必须的命令工具
JDK = JRE+编译、运行等命令工具

说明：

运行java程序的最小环境为JRE
开发java程序的最小环境为JDK

1.4.2 IDEA（目前最主流的）

说明：java的集成开发软件，JetBrains公司的，分为社区版(免费的)和终级版(收费的)
在这里插入图片描述

1.4.3 安装与下载

点我！！！！

1.5 java初体验-HelloWorld

package day01; //声明包day01(楼+单元)
public class HelloWorld { //声明类HelloWorld(房子)
	//主方法，为程序的入口(房子大门口)，程序的执行从main开始，main结束则程序结
	束
	public static void main(String[] args) {
	//输出hello world
	//1)严格区分大小写
	//2)所有符号必须是英文模式的
	//3)每句话必须以分号结尾
	System.out.println("hello world"); //双引号中的原样输出
	}
}

说明：
注释：解释性文本(计算机不执行)
1.单行注释：//
2.多行注释：/* */
3.文档注释：/** */

1.6 拓展

1.6.1 JAVA开发环境的使用

1）
在这里插入图片描述
解析：

进入类的根目录：
输入:javac 文件名.java 注意添加后缀.java
返回src目录：cd ..
使用：java 全类名.java文件名运行文件
注意此处不需要加.java或.class后缀

1.6.2 JAVA技术体系

在这里插入图片描述

补充：
Java Card

1.6.3 JAVA的特征

在这里插入图片描述

2. java基础

2.1 内存

内存单位换算:
1G=1024M(兆)
1M=1024KB(千字节)
1KB=1024B(字节)
1B=8bit(位)

2.2 变量

定义：变量类型变量名 = 变量值

//1.变量的声明
int a; //声明了一个整型的变量，名为a------开户
int b,c,d; //声明了三个整型的变量，名为b,c,d
//int a; //编译错误，变量不能同名

int e = 250; //声明一个整型变量e并赋值为250----开户的同时存钱
int f; //声明一个整型变量f----先开户
f = 250; //给变量f赋值为250-----后存钱
f = 360; //修改变量f的值为360

//2.变量的使用
int g = 5;
int h = g+10; //取出g的值5，加10后，再赋值给变量h
System.out.println(h); //输出变量h的值15
System.out.println("h"); //输出h，双引号中的原样输出
g = g+10; //在g本身基础之上增10
System.out.println(g); //输出g的值15

//System.out.println(i); //编译错误，变量i未声明
int i;
//System.out.println(i); //编译错误，变量i未初始化

2.3 命名规范（方法、变量、类）

只能包含字母、数字、_和$符，不能以数字开头
严格区分大小写
不能使用关键字
允许中文命名，但不建议，建议:

1.“英文的见名知意”
2.“小驼峰命名法”(一般用于变量、方法等)：多个单词第一个单词首字母小写，其余单词首字母大写
3.“大驼峰命名法”(一般用于类)：多个单词，首字母大写

int a1,a_5$,_3c,$6t;
//int a*b; //编译错误，不能包含*号等特殊符号
//int 1a; //编译错误，不能以数字开头
int aa = 5;
//System.out.println(aA); //编译错误，严格区分大小写
//int class; //编译错误，不能使用关键字
//int j; //允许，但不建议
//int 年龄; //允许，但不建议
//int nianLing; //允许，但不建议
int age; //建议"英文的见名知意"
int score,myScore,myJavaScore; //建议"小驼峰命名法"

拓展：

书写较多0的数字时，可以使用下划线分隔，便于查看
int a = 1_000_000;//下划线是一种表示方法

2.4 数据类型

2.4.1 介绍

说明：java的数据类型主要分为2大类：
1.基本数据类型：java的数据类型包含4类8种

整形：byte、short、int、long
浮点型：float、double
字符型：char
布尔型：boolean

2.引用类型：
对象、数组、集合等等

2.4.2 数据类型的测试

1）整形范围测试

//使用工具类进行测试
public static void main(String[] args) {
   //byte类型的数据范围 -128~127  1字节
   System.out.println("byte类型的最大值"+Byte.MAX_VALUE);//127
   System.out.println("byte类型的最小值"+Byte.MIN_VALUE);//-128

   //short类型的数据范围  -32768~32767 正负3w多  2字节
   System.out.println("short类型的最大值"+Short.MAX_VALUE);//32767
   System.out.println("short类型的最小值"+Short.MIN_VALUE);//-32768

   //int类型的数据范围   正负21亿多  4字节
   System.out.println("int类型的最大值"+Integer.MAX_VALUE);//2147483647
   System.out.println("int类型的最小值"+Integer.MIN_VALUE);//-2147483648

   //long类型的数据范围   -900万万亿多到900万万亿多 8字节
   System.out.println("long类型的最大值"+Long.MAX_VALUE);//9223372036854775807
   System.out.println("long类型的最小值"+Long.MIN_VALUE);//-9223372036854775808
}

补充:
char类型的范围是0~65535 、2字节

2）浮点型测试

//double：浮点型，8个字节，很大很大很大
//1.小数直接量默认为double型，若想表示float，需在数字后加F或f
double a = 25.678; //25.678为小数直接量，默认为double型
float b = 25.678F; //25.678F为float型直接量

//2.不能精确表示数据，运算时有可能会发生舍入误差，精确运算场合不能使用
double c=3.0,d=2.9;
System.out.println(c-d); //0.10000000000000009，有可能会发生舍入误差

3）布尔型数据测试

//1个字节,只能存储true或false
boolean a = true; //true为布尔型直接量
boolean b = false; //false为布尔型直接量
//boolean c = 250; //编译错误，布尔型变量只能存储true或false

4）字符型数据测试

采用Unicode编码格式，一个字符对应一个码，表现的形式是字符char，但本质上是码

ASCII码：‘a’----97 ‘A’----65 ‘0’----48

字符型直接量必须放在单引号中，并且只能有一个

char c1 = '女'; //字符女
char c2 = 'f'; //字符f
char c3 = '6'; //字符6
char c4 = ' '; //空格符
//char c5 = 女; //编译错误，字符型直接量必须放在单引号中
//char c6 = ''; //编译错误，必须有字符
//char c7 = '女性'; //编译错误，只能有一个字符
//char c8 = '10'; //编译错误，只能有一个数字字符
char c8 = 65; //0到65535之间
System.out.println(c8); //println()时会依据变量的类型来展示
//若c8为char类型，则以字符的形式来展示
//若c8为int类型，则以数字的形式来展示

补充：
1.特殊符号需要通过(反斜杠)\来转义
char c9 = '\\';
System.out.println(c9);
2.点我深入理解char

拓展：字符减整数0可以转化数据类型

char c = 65;
System.out.println(c);//字符型A
System.out.println(c-0);//减一个整数0，结果为整数型65
System.out.println(c-'0');//15，字符0的ASCII码为48，字符之间相减为ASCII码值相减

2.4.3 直接量（字面值）的特点

1.整数字面值是int类型
2.byte，short，char三种比int小的整数可以用范围内的值直接赋值
3.浮点数的字面值是double类型
4.字面值后缀l f d
5.进制前缀

//1.整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误
int a = 250; //250为整数直接量，默认为int类型
//int b = 10000000000; //编译错误，100亿默认为int类型，但超出范围了
//int c = 25.678; //编译错误，int型变量只能装整数

//2.两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
System.out.println(5/2); //2
System.out.println(2/5); //0
System.out.println(5/2.0); //2.5

//3.整数运算时若超范围，则发生溢出，溢出不是错误，但需要避免
int d = 2147483647; //int的最大值
d = d+1;
System.out.println(d); //-2147483648，发生溢出了

//4.长整型直接量需在数字后加L或l
long a = 25L; //25L为长整型直接量
//long b = 10000000000; //编译错误，100亿默认为int类型，但超出int范围了
long c = 10000000000L; //100亿L为长整型直接量
//long d = 25.678; //编译错误，长整型变量中只能装整数

//5.运算时若有可能溢出，建议在第1个数字后加L
long e = 1000000000*2*10L;
System.out.println(e); //200亿
long f = 1000000000*3*10L;
System.out.println(f); //不是300亿
long g = 1000000000L*3*10;
System.out.println(g); //300亿

2.4.4 数据类型的转化

在这里插入图片描述
两种方式：
1.自动/隐式类型转换：小类型到大类型
2.强制/显式类型转换：大类型到小类型

int a = 5;
long b = a; //自动类型转换(隐式类型转换)
int c = (int)b; //强制类型转换
long d = 5; //自动类型转换
double e = 5; //自动类型转换
long f = 10000000000L;
int g = (int)f;
System.out.println(g); //1410065408，强转有可能发生溢出
double h = 25.987;
int i = (int)h;
System.out.println(i); //25，强转有可能丢失精度

两点规则：
1.整数直接量可以直接给byte,short,char赋值，但不能超出范围
2.byte,short,char型数据参与运算时，系统会将其一律自动转换为int再运算

byte b1 = 5;
byte b2 = 6;
byte b3 = (byte)(b1+b2);
System.out.println(2+2); //4
System.out.println(2+'2'); //52，2加上'2'的码50
System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50
System.out.println('2'); //2，只有运算时才会转为int

2.5 运算符

优先级：（括单算关与，或条赋逗）
在这里插入图片描述

2.5.1 算术运算符

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

//%:取模/取余，余数为0即为整除
System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0---整除
System.out.println(2%8); //2，商0余2

2.5.2 单目运算符

++/–:自增1/自减1，可在变量前也可在变量后
符号在前，先变化后使用，符号在后，先使用后变化

1.单独使用时，在前在后都一样
2.被使用时，在前在后不一样

//演示++单独使用
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6
//演示++被使用
int a=5,b=5;
int c = a++; //1)将a++的值5赋值给c 2)a自增1变为6
int d = ++b; //1)将++b的值6赋值给d 2)b自增1变为6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6
//演示--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4
//演示--被使用:
int a=5,b=5;
int c = a--;
int d = --b;
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4

2.5.3 关系运算符

关系：>、<、>=、<=、==、!=
说明：
1)>(大于)、<(小于)
=(大于或等于)、<=(小于或等于)
==(等于)、!=(不等于)
2)关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false

//关系运算符测试
int a=5,b=10,c=5;
boolean b1 = a>b;
System.out.println(b1); //false
System.out.println(c<b); //true
System.out.println(a>=c); //true
System.out.println(a<=b); //true
System.out.println(a==c); //true
System.out.println(a!=c); //false
System.out.println(a+c>b); //false
System.out.println(a%2==0); //false
System.out.println(a++>5); //false-----a自增1变为6
System.out.println(a++>5); //true------a自增1变为7

2.5.4 逻辑运算符

逻辑：&&、||、!
逻辑运算是建立在关系运算的基础之上的
逻辑运算的结果也是boolean型

//&&：短路与(并且)，两边都为真则为真，见false则false
//第1个条件为false时，则发生短路(后面的不执行了)
int a=5,b=10,c=5;
boolean b1 = b>=a && b<c;
System.out.println(b1); //true&&false=false
System.out.println(b<=c && b>a); //false&&true=false
System.out.println(a==b && c>b); //false&&false=false
System.out.println(b!=c && a<b); //true&&true=true
//演示短路:
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c); //5，发生短路了

//||：短路或(或者)，有真则为真，见true则true
//第1个条件为true时，则发生短路(后面的不执行了)
System.out.println(b>=a || b<c); //true||false=true
System.out.println(b<=c || b>a); //false||true=true
System.out.println(b!=c || a<b); //true||true=true
System.out.println(a==b || c>b); //false||false=false
//演示短路:
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c); //5，发生短路了

//!：逻辑非(取反)，非真则假，非假则真
boolean b2 = !(a<b);
System.out.println(b2); //!true=false
System.out.println(!(a>b)); //!false=true

2.5.5 赋值运算符

赋值：=、+=、-=、*=、/=、%=
1.简单赋值运算符：=
2.扩展赋值运算符：+=,-=,*=,/=,%=
注意:扩展赋值运算符自带强转功能

//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转，改为: s=(short)(s+10);
s += 10; //相当于: s=(short)(s+10);自带强转功能

int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5

2.5.6 字符串连接符

连接符：+
1.若两边为数字，则做加法运算
2.若两边出现了字符串，则做字符串连接

int age = 39;
System.out.println("age="); //age=
System.out.println(age); //39
System.out.println("age="+age); //age=39
System.out.println("我的年龄是"+age); //我的年龄是39
System.out.println("我今年"+age+"岁了"); //我今年39岁了
String name = "WKJ";
System.out.println("name="+name); //name=WKJ
System.out.println("大家好，我叫"+name); //大家好，我叫WKJ
System.out.println("大家好，我叫"+name+"，今年"+age+"岁了"); //大家好，我
叫WKJ，今年39岁了

//任何类型与字符串连接，结果都是字符串型
System.out.println(10+20+""+30); //3030---------String
System.out.println(""+10+20+30); //102030-------String
System.out.println(10+20+30+""); //60-----------String

2.5.7 条件/三目运算符

语法：boolean?数1:数2
1.执行过程：
整个条件运算是有值的，它的值要么是?号后的数1，要么
是:号后的数2
2.计算boolean的值:
若为true，则整个表达式的值为?号后的数1
若为false，则整个表达式的值为:号后的数2

int num = 5;
int flag = num>0?1:-1;
System.out.println(flag); //1
int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max); //max=8

2.6 程序结构

任何复杂的业务逻辑都可以通过三种结构来实现：
顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句，并非每句必走
循环结构：有条件的执行某语句多次，并非每句必走

2.6.1 顺序结构

程序自上而下执行，特点是结构内每个语句都要执行

2.6.2 分支结构

1.单分支

if结构
1).语法:
if(boolean){
语句块------------基于条件执行的语句
}
2).执行过程:
判断boolean的值:
若为true，则执行语句块(整个结束)
若为false，则直接结束

//测试
//1)偶数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
	System.out.println(num+"是偶数");
}
System.out.println("继续执行...");

//2)满500打8折:
double price = 300.0; //消费金额 带数(600.0,300.0)
if(price>=500){ //满500
	price*=0.8; //打8折
}
System.out.println("最终消费金额为:"+price);

//3)判断成绩合法------在0到100之间(包括)
double score = 850; //带数(95,850,-54)
if(score>=0 && score<=100){
	System.out.println("成绩合法");
}
System.out.println("继续执行...");

2.双分支

if…else结构：
1)语法:
if(boolean){
语句块1
}else{
语句块2
}
2)执行过程:
判断boolean的值:
若为true，则执行语句块1(整个结束)
若为false，则执行语句块2(整个结束)
3)说明:
语句块1和语句块2，必走其中之一------------2选1

//1)偶数、奇数的判断:
int num = 5; //带数(6,5)
if(num%2==0){
	System.out.println(num+"是偶数");
}else{
	System.out.println(num+"是奇数");
}
System.out.println("继续执行...");

//2)满500打8折，不满500打9折:
double price = 300.0; //带数(600.0,300.0)
if(price>=500){
	price *= 0.8;
}else{
	price *= 0.9;
}
System.out.println("最终结算金额为:"+price);

//3)判断成绩是否合法---0到100(包括)之间表示合法，否则为不合法
double score = -25; //带数(95,540,-25)
if(score>=0 && score<=100){
	System.out.println("成绩合法");
}else{
	System.out.println("成绩不合法");
}

3.多分支

if…else if结构：
1)语法:
if(boolean-1){
   语句块1
}else if(boolean-2){
   语句块2
}else if(boolean-3){
   语句块3
}else{
   语句块4
}
2)执行过程:
判断boolean-1，若为true则执行语句块1(结束)，若为false则
再判断boolean-2，若为true则执行语句块2(结束)，若为false则
再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束)
3)说明:
语句块1/2/3/4，必走其中之一------------多选1

package day04;
import java.util.Scanner;
//成绩等级判断
public class ScoreLevel {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入成绩:");
		double score = scan.nextDouble();
		//带数(888,-45,95,85,65,45)
		if(score<0 || score>100){
			System.out.println("成绩不合法");
		}else if(score>=90){ //合法
			System.out.println("A-优秀");
		}else if(score>=80){
			System.out.println("B-良好");
		}else if(score>=60){
			System.out.println("C-中等");
		}else{
			System.out.println("D-不及格");
		}
	}
}

补充：
Scanner接收用户输入的数据：共3步（背）
注：输入的数据类型不同，next的数据也不同，例如：
double类型对应nextDouble、int类型对应nextInt

package day04;
import java.util.Scanner; //1.导入一个扫描仪
//Scanner的演示
public class ScannerDemo {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in); //2.新建扫描仪，叫scan
		System.out.println("请输入年龄:");
		int age = scan.nextInt(); //3.扫描一个整数并赋值给age
		System.out.println("请输入商品价格:");
		double price = scan.nextDouble(); //3.扫描一个小数并赋值给price
		System.out.println("年龄为:"+age+"，商品价格为:"+price);
	}
}

4.switch……case（多分支）

switch…case结构：
优点：效率高、结构清晰
缺点：只能对整数判断相等
break：跳出switch
注：switch可以作用于的数据类型有: byte,short,char,int,String,枚举

package day04;
import java.util.Scanner;
//命令解析程序
public class CommandBySwitch {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请选择功能: 1.存款 2.取款 3.退卡");
		int command = scan.nextInt();
		switch(command){
		case 1:
		System.out.println("存款业务处理...");
		break;
		case 2:
		System.out.println("取款业务处理...");
		break;
		case 3:
		System.out.println("退卡");
		break;
		default:
		System.out.println("输入错误");
		}
	}
}

拓展：
书写多个case情况时，可以按如下写法：
case 1: case 3: case 5: case 7: case 8: case 10: case 12:……语句块

2.6.3 循环结构

循环：反复多次执行一段相同或相似的代码
循环三要素：非常重要

循环变量的初始化
循环的条件(以循环变量为基础)
循环变量的改变(向着循环的结束变)

循环变量：在整个循环过程中所反复改变的那个数

案例：

1)输出5次"行动是成功的阶梯":
2)输出9的乘法表:
19=9
29=18
39=27
49=36
59=45
69=54
79=63
89=72
9*9=81

1.while结构

while结构：先判断后执行，有可能一次都不执行
1)语法:
while(boolean){
语句块/循环体----------反复执行的代码
}
2)执行过程:
先判断boolean的值，若为true则执行语句块，
再判断boolean的值，若为true则再执行语句块，
再判断boolean的值，若为true则再执行语句块，
如此反复，直到boolean的值为false时，while循环结束

package day04;
//while结构的演示
public class WhileDemo {
	public static void main(String[] args) {
		//1)输出5次"行动是成功的阶梯":
		int times = 0; //1)循环变量的初始化
		while(times<5){ //2)循环的条件
			System.out.println("行动是成功的阶梯");
			times++;
		}
		System.out.println("继续执行...");
		/* 执行过程:----带数
		times=0
		true 输出 times=1
		true 输出 times=2
		true 输出 times=3
		true 输出 times=4
		true 输出 times=5
		false while循环结束
		输出继续执行...
		*/
		//2)输出9的乘法表: 3*9=27
		int num = 1;
		while(num<=9){
			System.out.println(num+"*9="+num*9);
			num+=2; //num++;
		}
		System.out.println("继续执行...");
		}
	}
}

猜数字案例

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int num = (int)(Math.random()*1000+1); //1到1000的随机数
		System.out.println(num); //作弊
		//300(大),200(小),250(对)
		System.out.println("猜吧!");
		int guess = scan.nextInt(); //1.
		while(guess!=num){ //2.
			if(guess>num){
				System.out.println("太大了");
			}else{
				System.out.println("太小了");
			}
			System.out.println("猜吧!");
			guess = scan.nextInt(); //3.
		}
		System.out.println("恭喜你猜对了!");
	}
}

补充：
随机数的使用：Math.random()
默认生成0-0.999999循环的数
想要生成1-1000内的随机数：
过程如下
Math.random()--------------0.0到0.999999999999999…
*1000----------------------0.0到999.9999999999999…
+1-------------------------1.0到1000.999999999999…
(int)----------------------1到1000
注意：要先乘1000再强转，否则就会先取整数0，导致结果错误

2.do…while结构

先执行后判断，至少执行一次
1)语法:
do{
语句块
}while(boolean);
2)执行过程:
先执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，再判断boolean的值，若为true则
再执行语句块，如此反复，直到boolean的值为false时，do…while结束

package day04;
import java.util.Scanner;
//猜数字小游戏
public class Guessing {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int num = (int)(Math.random()*1000+1); //1到1000的随机数
		System.out.println(num); //作弊
		//假设num=250
		//300(大),200(小),250(对)
		int guess;
		do{
			System.out.println("猜吧!");
			guess = scan.nextInt(); //1+3
			if(guess>num){
				System.out.println("太大了");
			}else if(guess<num){
				System.out.println("太小了");
			}else{
				System.out.println("恭喜你猜对了!");
			}
		}while(guess!=num); //2
	}
}

3.for结构

应用率最高，与次数相关的循环
1)语法:
// 1 2 3
for(要素1;要素2;要素3){
语句块/循环体---------------反复执行的代码 4
}
2)执行过程:
1243243243243243…2

案例1

//for循环测试
for(int times=0;times<5;times++){
	System.out.println("行动是成功的阶梯");
}
System.out.println("继续执行...");
/*
执行过程:
times=0 true 输出
times=1 true 输出
times=2 true 输出
times=3 true 输出
times=4 true 输出
times=5 false for循环结束
输出继续执行...
*/

//for中的循环变量num的作用域，仅在当前for中-----特殊情况特殊记
for(int num=1;num<=9;num++){
	System.out.println(num+"*9="+num*9);
}
for(int num=1;num<=9;num+=2){
	System.out.println(num+"*9="+num*9);
}

//累加和:1+2+3+4+...+99+100=?
int sum = 0; //存和
for(int num=1;num<=100;num++){
	sum = sum+num;
}
System.out.println("sum="+sum);
/*
执行过程:
sum=0
num=1 sum=1
num=2 sum=1+2
num=3 sum=1+2+3
num=4 sum=1+2+3+4
...
num=99 sum=1+2+3+4+...+99
num=100 sum=1+2+3+4+...+99+100
num=101 false
*/

案例2：随机加法运算器

说明：
1.系统随机给出一道加法题（两个加数在0-100内）
2.用户输入结果
3.判定分数，答对加10分，答错不扣分，程序结束后输出总分

package day05;
import java.util.Scanner;
//随机加法运算器
public class Addition {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int score = 0; //总分
		for(int i=1;i<=10;i++){ //10次 (1)25+15=?
			int a = (int)(Math.random()*100); //加数a(0到99)
			int b = (int)(Math.random()*100); //加数b(0到99)
			int result = a+b; //存正确答案
			System.out.println("("+i+")"+a+"+"+b+"=?"); //1.出题
			System.out.println("算吧!");
			int answer = scan.nextInt(); //2.答题
			if(answer==-1){ //3.判题
				break;
			}
			if(answer==result){
				System.out.println("答对了");
				score += 10; //答对1题加10分
			}else{
				System.out.println("答错了");
			}
		}
		System.out.println("总分为:"+score);
	}
}

4.两个关键字：break，continue

break：跳出循环
continue：跳过循环体中剩余语句而进入下一次循环

案例1

//break测试
for(int num=1;num<=9;num++){
	if(num==4){ //在某种特定条件下，提前结束循环
	break; //跳出循环
}
System.out.println(num+"*9="+num*9);
}
/*
执行过程:
num=1 1*9=9
num=2 2*9=18
num=3 3*9=27
num=4
*/

案例2

//输出9的乘法表，跳过能被3整除的
for(int num=1;num<=9;num++){
	if(num%3==0){
		continue; //跳过循环体中剩余语句而进入下一次循环
	}
	System.out.println(num+"*9="+num*9);
}

//输出9的乘法表，只要不能被3整除的
for(int num=1;num<=9;num++){
	if(num%3!=0){
		System.out.println(num+"*9="+num*9);
	}
}

5.嵌套循环

1.循环中套循环，常常多行多列时使用，外层控制行，内层控制列
2.执行规则：外层循环走一次，内层循环走所有次
3.建议：嵌套层数越少越好，能用一层就不用两层，能用两层就不用三层
4.break只能跳出当前一层循环

package day05;
//九九乘法表
public class MultiTable {
	public static void main(String[] args) {
		for(int num=1;num<=9;num++){ //控制行
			for(int i=1;i<=num;i++){ //控制列
				System.out.print(i+"*"+num+"="+i*num+"\t");
			}
			System.out.println(); //换行
		}
		/* 执行过程:
		num=3
		i=1 1*3=3
		i=2 2*3=6
		i=3 3*3=9
		i=4 false
		换行
		num=2
		i=1 1*2=2
		i=2 2*2=4
		i=3 false
		换行
		num=1
		i=1 1*1=1
		i=2 false
		换行
		*/
	}
}

补充：
\t：水平制表位，固定占8位

6.总结：
三种循环结构如何选择：

先看循环是否与次数相关：

若有关-----------------------------------------------直接上for
若无关，再看要素1与要素3是否相同

若相同------------------------------------------直接上do…while
若不同------------------------------------------直接上while

2.7 数组

1.是一种数据类型(引用类型)
2.相同数据类型元素的集合

2.7.1 数组的定义及初始化

//定义
//声明整型数组arr，包含10个元素，每个元素都是int类型，默认值为0
int[] arr = new int[10];

//初始化：初始化数组的元素
int[] arr1 = new int[3]; //0,0,0
int[] arr2 = {2,5,8}; //2,5,8
int[] arr3 = new int[]{2,5,8}; //2,5,8
int[] arr4;
//arr4 = {2,5,8}; //编译错误，此方式只能声明同时初始化
arr4 = new int[]{2,5,8}; //正确

总结：
数组的初始化分为动态初始化（1种），静态初始化（2种）

2.7.2 访问数组的元素

//通过(数组名.length)可以获取数组的长度
int[] arr = new int[3];
System.out.println("数组的长度为:"+arr.length); //3

//通过下标/索引来访问数组中的元素，下标从0开始，最大到(数组的长度-1)
int[] arr = new int[3];
System.out.println(arr[0]); //0，输出第1个元素的值
arr[0] = 100; //给第1个元素赋值为100
arr[1] = 200; //给第2个元素赋值为200
arr[2] = 300; //给第3个元素赋值为300
//arr[3] = 400; //运行时发生ArrayIndexOutOfBoundsException数组下标越界异
常
System.out.println(arr[arr.length-1]); //300，输出最后一个元素的值

//遍历/迭代：从头到尾挨个走一遍
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){ //遍历arr数组
	arr[i] = (int)(Math.random()*100); //给每个元素赋值为0到99的随机数
	System.out.println(arr[i]); //输出每个元素的值
}

补充：
1.数组中的元素有默认值,如下：

byte,short,int,long,char------------------0
float,double------------------------------0.0
boolean-----------------------------------false

2.异常：

ArrayIndexOutOfBoundsException：数组下标越界异常

数组的下标为0到(数组长度-1)，若超出这个范围则会发生数组下标越界异常

2.7.3 数组工具类

1.Arrays.copyof(源数组，目标数组的长度)
2.System.arraycopy(源数组，源数组的起始下标，目标数组，目标数组的起始下标，要复制的元素个数)
3.Arrays.sort（源数组）
4.Arrays.toString(源数组)

//System.arraycopy测试
int[] a = {10,20,30,40,50};
int[] b = new int[6]; //0,0,0,0,0,0
//a:源数组
//1:源数组的起始下标
//b:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数
System.arraycopy(a,1,b,0,4); //灵活性好
for(int i=0;i<b.length;i++){
	System.out.println(b[i]);
}

//Arrays.copyof测试
int[] a = {10,20,30,40,50};
//a:源数组
//b:目标数组
//6:目标数组的长度
// ---若目标数组长度>源数组长度，则末尾补默认值
// ---若目标数组长度<源数组长度，则将末尾的截掉
int[] b = Arrays.copyOf(a,6); //灵活性差
for(int i=0;i<b.length;i++){
	System.out.println(b[i]);
}
int[] a = {10,20,30,40,50};

//数组的扩容(创建了一个更大的新的数组，并将数据复制进去)
a = Arrays.copyOf(a,a.length-1);
for(int i=0;i<a.length;i++){
	System.out.println(a[i]);
}

需求：求数组元素的最大值，并将其放在数组最后一个元素的下一个位置

package day06;
import java.util.Arrays;
//求数组元素的最大值，并将其放在数组最后一个元素的下一个位置
public class MaxOfArray {
	public static void main(String[] args) {
		int[] arr = new int[10];
		for(int i=0;i<arr.length;i++){
			arr[i] = (int)(Math.random()*100);
			System.out.println(arr[i]);
		}
		int max = arr[0]; //假设第1个元素为最大值
		for(int i=1;i<arr.length;i++){ //遍历剩余元素
			if(arr[i]>max){ //若剩余元素大于max
				max = arr[i]; //将max修改为较大的
			}
		}
		System.out.println("最大值为:"+max);
		arr = Arrays.copyOf(arr,arr.length+1); //扩容
		arr[arr.length-1] = max; //将max赋到最后一个元素上
		for(int i=0;i<arr.length;i++){
			System.out.println(arr[i]);
		}
	}
}

//排序
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){
	arr[i] = (int)(Math.random()*100);
	System.out.println(arr[i]);
}
Arrays.sort(arr); //对arr进行升序排列
System.out.println("排序后:");
for(int i=0;i<arr.length;i++){
	System.out.println(arr[i]);
}
System.out.println("倒着输出:");
for(int i=arr.length-1;i>=0;i--){ //数据还是升序的，只是倒着展示而已
	System.out.println(arr[i]);
}
System.out.println("第1个元素为:"+arr[0]); //小的

2.7.4 引用类型数组

给引用类型数组的元素赋值时，需要new个对象
若想访问数组元素的属性/方法，需要通过数组元素去打点

Student[] stus = new Student[3];
stus[0] = new Student("zhangsan",25,"LF");
stus[1] = new Student("lisi",24,"JMS");
stus[2] = new Student("wangwu",26,"SD");
System.out.println(stus[0].name); //输出第1个学生的名字
stus[1].age = 23; //修改第2个学生的年龄为23
stus[2].sayHi(); //第3个学生跟大家问好
for(int i=0;i<stus.length;i++){ //遍历学生数组
    System.out.println(stus[i].name); //输出每个学生的名字
    stus[i].sayHi(); //每个学生跟大家问好
}

2.8 方法（函数、过程）

作用：封装一段特定的业务逻辑功能
建议：尽可能独立，一个方法只干一件事
方法可以被反复多次调用
优点：减少代码重复，有利于代码维护
何时用：只要是一个独立的业务功能，就得封装到一个方法中

2.8.1 方法的定义：五要素

修饰词返回值类型方法名(参数列表){
方法体----具体的业务功能实现
}
参数列表：

形参：形式参数，定义方法时的参数称为形参
实参：实际参数，调用方法时的参数称为实参

//无参无返回值
public static void say(){
	System.out.println("大家好，我叫WKJ，今年38岁了");
}

//有参无返回值
public static void sayHi(String name){ //----------------------形参
	System.out.println("大家好，我叫"+name+"，今年38岁了");
}

//有参无返回值
public static void sayHello(String name,int age){ //-----------形参
	if(age>=60){ //在某种特定条件下，提前结束方法
		return; //结束方法
	}
	System.out.println("大家好，我叫"+name+"，今年"+age+"岁了");
}

//无参有返回值
public static double getNum(){
	//在有返回值的方法中，必须得通过return来返回数据
	//return; //编译错误，return后必须跟一个数据
	//return "abc"; //编译错误，return后数据的类型必须与返回值类型匹配
	return 8.88; //1)结束方法的执行 2)返回结果给调用方
}

//有参有返回值
public static int plus(int num1,int num2){
	int num = num1+num2;
	return num; //返回的是num里面的那个数
	//return num1+num2; //返回的是num1与num2的和
}

//扩展练习
public static int[] testArray(int len,int max) {
	int[] arr = new int[len];
	for (int i = 0; i < arr.length; i++) {
		arr[i] = (int) (Math.random() * (max + 1));
	}
	return arr;
}

补充：
想要生成0-10的随机数：
利用（10+1）*随机数

2.8.2 方法的调用

//无返回值：方法名(有参传参);
public static void main(String[] args) {
	//say(); //调用say()方法
	//sayHi(); //编译错误，有参则必须传参
	//sayHi(250); //编译错误，参数类型必须匹配
	sayHi("zhangsan"); //String name="zhangsan" //------------实参
	sayHi("lisi"); //String name="lisi" //--------------------实参
	sayHi("wangwu"); //String name="wangwu" //----------------实参
	sayHello("zhangsan",25); //String name="zhangsan",int age=25----实参
	sayHello("lisi",24); //-------------------------实参
	sayHello("zhangsan",25);
	sayHello("lisi",66);
	

}

//有返回值：数据类型 变量 = 方法名(有参传参);
public static void main(String[] args) {
	double a = getNum(); //getNum()的值就是return后的那个数
	System.out.println(a); //8.88---模拟对返回值的后续操作
	int b = plus(5,6);
	System.out.println(b); //11--模拟对返回值的后续操作
	int m=50,n=60;
	int c = plus(m,n); //传的是m与n里面的数
	System.out.println(c); //110--模拟对返回值的后续操作
	int[] d = testArray(10,100);
	System.out.println("长度为:"+d.length); //10---模拟对返回值的后续操作
	Arrays.sort(d); //排序---模拟对返回值的后续操作
	for(int i=0;i<d.length;i++){ //输出---模拟对返回值的后续操作
		System.out.println(d[i]);
	}
}

2.8.3 return

return 值; //1) 结束方法的执行 2)返回结果给调用方
------用在有返回值的方法中
return; //1)结束方法的执---------------------用在无返回值的方法中

public static void main(String[] args){
	say();
	sayHi("zhangsan");
	sayHello("zhangsan",25);
	double a = getNum(); //输出a---模拟对返回值的后续操作
	int b = plus(5,6); //输出b---模拟对返回值的后续操作
	int m=50,n=60; int c = plus(m,n); //输出c---模拟对返回值的后续操作
	int[] d = testArray(5,100); //输出d的长度，输出d中每个元素的值---模拟对返回值的后续操
	作
}
public static void say(){ 固定的问好 }
public static void sayHi(String name){ 问好，名字写活了 }
public static void sayHello(String name,int age){ 问好，名字和年龄都写活了 }
public static double getNum(){ return 8.88; }
public static int plus(int num1,int num2){ return num1+num2; }
public static int[] testArray(int len,int max){
	int[] arr = new ...; ...; return arr;
}

2.8.4 方法的重载(overload)

发生在同一类中，方法名相同，参数列表不同
编译器在编译时会根据方法的签名自动绑定方法

方法的签名：方法名+参数列表

public class OverloadDemo {
    public static void main(String[] args) {
        Aoo o = new Aoo();
        o.show(); //自动绑定无参show方法
        o.show("zhangsan"); //自动绑定String参的show方法
        o.show(25); //自动绑定int参的show方法
        o.show("zhangsan",25); //自动绑定String+int参的show方法
        o.show(25,"zhangsan"); //自动绑定int+String参的show方法
    }
}

class Aoo{
    void show(){}
    void show(String name){}
    void show(int age){}
    void show(String name,int age){}
    void show(int age,String name){}
    //int show(){ return 1; } //编译错误，重载与返回值类型无关
    //void show(String address){} //编译错误，重载与参数名称无关
}

2.8.5 方法的重写(override/overriding)

1、继承后，子类就拥有了父类的功能

2、那么在子类中，可以添加子类特有的功能也可以修改父类的原有功能

3、子类中方法签名与父类完全一样(包括方法的返回值，方法名和参数列表，完全一致)时，会发生覆盖/复写操作，相当于修改功能

注意：

1、父类中的私有方法不能被重写

2、子类重写父类方法时，修饰符要大于等于父类修饰符的权限

class 餐馆{
    void 做餐(){ 做中餐 }
}
A:我继承餐馆后，我还是想做中餐-------------不需要重写
class 我 extends 餐馆{
}
B:我继承餐馆后，我想改做西餐---------------需要重写
class 我 extends 餐馆{
    void 做餐(){ 做西餐 }
}
C:我继承餐馆后，想在中餐基础之上加入西餐-----需要重写(先super中餐，再加入西餐)
class 我 extends 餐馆{
    void 做餐(){
        super.做餐();
        做西餐
    }
}