Java基础小节笔记
一、Java基础知识记录
1.java开发环境
1)java编译运行过程:----------常见面试题
1.1)编译期:.java源文件，经过编译，生成.class字节码文件
1.2)运行期:JVM加载.class并运行.class(0和1)
特点:跨平台、一次编程到处使用
2)名词解释:------------------常见面试题
2.1)JVM:java虚拟机
加载.class并运行.class
2.2)JRE:java运行环境
除了包含JVM以外还包含了运行java程序所必须的环境
JRE=JVM+java系统类库(小零件)
2.3)JDK:java开发工具包
除了包含JRE以外还包含了开发java程序所必须的命令工具
JDK=JRE+编译、运行等命令工具
3)配置环境变量-----------了解
3.1)JAVA_HOME:指向jdk的安装目录
3.2)CLASSPATH:表示类的搜索路径，一般简写为.
3.3)PATH:指向jdk下的bin目录
2.eclipse:
1)IBM、开源的、免费的、不需要安装仅需解压即可
2)开发步骤:
2.1)新建Java项目/工程-------------小区
2.2)新建Java包--------------------楼+单元
2.3)新建Java类--------------------房子
main中: System.out.println(“Hello”);
3)注释:解释性文本
3.1)单行注释://
3.2)多行注释:/* /
3.3)文档注释:/* */
项目、包、类对应的是：东日瑞景小区、3号楼2单元、601
工作空间:你所创建的所有java项目的默认保存地址
要先装JDK，再运行eclipse
eclipse:IBM公司用java语言开发的一套软件
开源:开放源代码、免费的
C语言的编译运行过程:
.c源文件，经过编译，直接生成可执行文件(0和1)
计算机:只能识别0和1
java写出来的不是0和1
3.变量、java基本类型
小节：
早期的计算机--------算数(数字)
现在的计算机--------算数(数字、文字、图片、音频、视频等)
计算机的本质：Input(输入数据)+Output(输出数据)
计算机的本质是输入数据和输出数据，而变量是存储数据的。
1.变量
存数的，代词，指代的就是它所存的那个数。
1)声明:
int a; //读：声明一个整型的变量，名为a
如果多个变量类型一样，可以在一条语句中声明，中间用逗号分隔。
int b,c,d; //声明三个整型的变量，名为b,c,d
2)初始化:第一次赋值
2.1)声明同时初始化:
int a = 250; //声明整型变量a并赋值为250
2.2)先声明后初始化:
int a; //声明整型变量a
a = 250; //给变量a赋值为250
在java中等号就是赋值，存数的意思。
3)使用:
3.1)对变量的使用就是对它所存的那个数的使用
int a = 5;
int b = a+10; //取出a的值5，加10后，再赋值给变量b
System.out.println(b); //输出变量b的值15
System.out.println(“b”); //输出b，双引号中的原样输出
a = a+10; //取出a的值5，加10后，再赋值给a
//在a本身基础之上增10
System.out.println(a); //15
3.2)变量的使用必须与数据类型匹配
int a = 3.14; //编译错误，数据类型不匹配
在下面出现红色波浪线，是出现编译错误。
3.3)变量在使用之前必须声明并初始化
System.out.println(m); //编译错误，m未声明
int m;
System.out.println(m); //编译错误，m未初始化
错误：Variable ‘m’ might not have been initialized
翻译：变量“m”可能尚未初始化
4)命名:
规定：变量的命名必须符合Java标识符的规则
Java标识符：在java源程序中凡是程序员有权利自己命名的单词都是标识符。
4.1)只能包含字母、数字、_和$符（叫：刀了符），并且不能以数字开头
4.2)严格区分大小写
4.3)不能使用关键字
下面在eclipse中这种紫色的（还有void），都叫做关键字。
package day01; //声明包day01
public class HelloWorld { //声明类HelloWorld
//主方法，为程序的入口
//程序的执行从main开始，main结束则程序结束
public static void main(String[] args) {
//输出HelloWorld
//1)严格区分大小写
//2)所有符号必须是英文模式的
//3)每句话必须以分号结尾
//4)println():输出并换行
// print():输出不换行
System.out.print("Hello");
System.out.println("World");
System.out.println("北京欢迎你");
System.out.println("当日事当日毕");
}
}
建议：
4.4)可以中文命名，但不建议，建议**“英文的见名知意”、“驼峰命名法”**。
直接int a = 1;的话，不直观，不知道写的是什么。
如果中文命名，纯java是没问题的。但是有些开源框架不支持中文。
int a; //不直观
int 年龄; //直观但不专业
int ningLing; //既不直观也不专业
int age; //建议
score,myScore,myJavaScore------------驼峰命名法（也叫小驼峰法）
Score,MyScore,MyJavaScore------------帕斯卡命名法（也叫大驼峰法）
驼峰命名法（Camel-Case）：命名：变量和方法
当变量名或函式名是由一个或多个单字连结在一起，而构成的唯一识别字时，首字母以小写开头，每个单词首字母大写（第一个单词除外）。
如：变量：ICustomerCardService customerCardService;
方法：IPage pages = customerCardService.getCardVOPage((Page) Condition.getPage(query), params);
帕斯卡命名法：命名：类
大驼峰法（Upper Camel Case）也称为：帕斯卡命名法：（pascal方法）常用于类名，函数名，属性，命名空间。相比小驼峰法，大驼峰法把第一个单词的首字母也大写了。例如：public class HelloWorld。
命名规范
驼峰命名法使用前注意事项：
1、由于Java面向对象编程的特性, 在命名时应尽量选择名词。
2、驼峰命名法（Camel-Case）: 当变量名或函式名是由一个或多个单字连结在一起，而构成的唯一识别字时，首字母以小写开头，每个单词首字母大写（第一个单词除外）。如：myFirstName
一 、包名的书写规范 （Package）
推荐使用公司或机构的顶级域名为包名的前缀，目的是保证各公司/机构内所使用的包名的唯一性。
包名全部为小写字母，且具有实际的区分意义。
1.1 一般要求
1、选择有意义的名字，能快速地传达该类的用途。
2、所有包的命名必须采用小写英文字母。
1.2 实际应用 应用系统中经常应用分层，Dao层（数据库访问）、Service层（业务处理）、Web层（页面控制action类）。
1、包名的前几个为固定名称, 如果是网站的话，采用网站的域名的反写，如果域名还没有确定的话，采用公司固定的几个名称。如：net.vschool
2、在包名的接下来一个单词为模块的名称。如：用户模块，包名为net.vschool.user
3、关于模块的访问操作，采用分层形式,一般分为：
Dao层操作：一般定义在net.vschool.xxx.dao 中，其中xxx为模块名称。
Service层操作：一般定义在net.vschool.xxx.servie中。
web层操作：一般定义在 net.vschool.xxx.action中。
如下关于用户模块的例子：
net.vschool.user
net.vschool.user.dao
net.vschool.user.action
net.vschool.user.service
二 、类名的书写规范 (Class)
类名必须使用名词，如果一个类名内含多个单词，那么各个单词第一个字母大写，后续字母小写，起伏呈驼峰状，
人称驼峰式命名。给类名命名时，必须保证准确、简洁且容易理解。尽量使用完整单词，避免使用缩写词（除了大
家公认的）。
2.1 类的命名
2.1.1 一般要求
1、选择有意义的名字，能快速地传达该类的用途。
2、参照java驼峰命名法，类名的首字母必须采用大写的形式，如果类名为多词组合而成的话，那么每个词的首字母必须采用大写。如：StudentAnswer.java
3、当要区别接口类和实现类的时候，可以在类的后面加上“Impl”。
如：接口类：UserInterface.java 接口实现类：UserInterfaceImpl
4、推荐实体类没有后缀名。
2.1.2 实际应用
应用系统中经常应用分层，Dao层（数据库访问）、Service层（业务处理）、Web层（页面控制action类），每一层的类的名称尽量带上该层后缀。
1、Dao层
a、接口类：采用JavaBean+Interface+Dao的形式来定义,即，实体对象+Interface+Dao。
如：用户对象接口类： UserInterfaceDao，其中xxx为模块名称。
b、实现类：采用JavaBean+Interface+Impl+Dao的形式来定义,即，实体对象+Interface+Impl+Dao。
如：用户对象实现类：UserInterfaceImplDao
2、Service层
a、接口类：采用Xxx+Interface+Service的形式来定义,即，模块+Interface+Service。
如：用户管理接口类：UserMsgInterfaceServiec
b、实现类：采用Xxx+Interface+Impl+Service的形式来定义,即，模块+Interface+Impl+Service。
如：用户管理实现类：UserMsgInterfaceImplServiec
3、Web层（action类）
a、实现类：采用县 Xxx+Operator+Action的形式来定义,即，模块+操作+Action。
如用户模块User+删除操作Delete+Action = UserDeleteAction
2.1 变量的命名
2.2.1 普通变量
2.2.2.1 一般要求
1、选择有意义的名字，能快速地传达该变量的用途。
2、参照java驼峰命名法，首字母以小写开头，每个单词首字母大写（第一个单词除外）。
2.2.2.2 实际应用
1、变量命名采用基本结构为typeVariableName，使用3字符前缀来表示数据类型。
例如，定义一个整形变量：intDocCount，其中int表明数据类型，后面为表意的英文名，每个单词首字母大写。
2、变量使用技巧：
a、在一段函数中不使用同一个变量表示前后意义不同的两个数值。
b、除非是在循环中，否则一般不推荐使用单个字母作为变量名，i、j、k等只作为小型循环的循环索引变量。
c、避免用Flag来命名状态变量。
d、用Is来命名逻辑变量，如：blnFileIsFound。通过这种给布尔变量肯定形式的命名方式，使得其它开发人员能够更为清楚的理解布尔变量所代表的意义。
e、如果需要对变量名进行缩写时，一定要注意整个代码中缩写规则的一致性。例如，如果在代码的某些区域中使用intCnt，而在另一些区域中又使用intCount，就会给代码增加不必要的复杂性。建议变量名中尽量不要出现缩写。
2.2.2 静态变量
1、选择有意义的名字，能快速地传达该变量的用途。
2、参照java驼峰命名法，采用全部大写的形式来书写，对于采用多词合成的变量采用“_”来连接各单词。
如：USER_LIST
2.3 方法的命名
2.3.1 一般要求
1、选择有意义的名字，能快速地传达该方法的用途。
2、参照java驼峰命名法，首字母以小写开头，每个单词首字母大写（第一个单词除外）。
2.3.2 实际应用
1、方法表示一种行为，它代表一种动作，最好是一个动词或者动词词组或者第一个单词为一个动词。
2、属性方法：以get/set开头，其后跟字段名称，字段名称首字母大写。如：getUserName()
3、数据层方法：只能以insert（插入）,delete（删除）,update（更新）,select（查找）,count（统计）开头，其他层方法避免以这个5个单词开头，以免造成误解。
4、服务层方法，根据方法的行为命名，只描述方法的意义，而不采用方法的目的命名。比如系统的添加新用户，用户可以前台注册，也可以管理员后台添加，方法会被重用，所以最好不要用使用register，采用add会更好写。避免使用与web层相关的方法。
5、Web层方法最好是贴近web的语言，如register，login，logout等方法。
三 注释的书写规范 （Javadoc）
Java除了可以采用我们常见的注释方式（//、/* */）之外，Java语言规范还定义了一种特殊的注释，也就是我们所说的Javadoc注释，以/*开头，而以/结束， Javadoc 注释可以被自动转为在线文档，省去了单独编写程序文档的麻烦。 推荐使用。
Javadoc注释主要涉及范围：类、属性、方法。
例如：
代码如下:
package org.ietf.jgss;
import java.net.InetAddress;
import java.util.Arrays;
/**
* 该类的整体性描述。
* @author 作者
* @version 1.0, 05/22/07
* @since 1.0
*/
public class ChannelBinding {
/**
*对该变量的备注信息
*/
private InetAddress initiator;
/**
* 对该类的构造函数的备注信息。
* @param initAddr 对参数的备注。
* @param acceptAddr对参数的备注。
* @param appData对参数的备注。
*/
public ChannelBinding(InetAddress initAddr, InetAddress acceptAddr,
byte[] appData) {
}
/**
* 对该类的具体一函数的备注信息
* @param obj 参数的备注信息
* @return 返回值的备注信息
*/
public boolean equals(Object obj) {
if (this == obj)
return true;
if (! (obj instanceof ChannelBinding))
return false;
ChannelBinding cb = (ChannelBinding) obj;
return Arrays.equals(appData, cb.appData);
}
}
四 其他书写规范
4.1 Jsp页面名称的书写规范
1．全部采用小写的英文字符和”_ ”组成。
2．整体采用模块名+操作的形式。如：user_view.jsp
3．Jsp页面尽可能与action的意思对应，如UserListAction 对应者user_list.jsp
接口：
使用驼峰式命名。除了用名词外，还可以用形容词命名（体现其功能特性）
方法：
规定用动词命名，适合用驼峰式命名，但与类名的最大区别在于，首字母必须小写
变量：
规定为名词，其他同“方法”命名方式一样。变量名非常关键，应含有具体意义且易于理解，一般不允许使用单个字母做变量名。除非一些临时性变量，像在循环中使用到的计数器等。在使用单个字母做变量名时，一般I、J、K用来命名整形变量。
常量：
规定全用大写字母表示，如果名字必须用多个单词来表示，那么各单词间用“-“分隔。常量要求必须意义明确，能表达出常量的含义。
2.基本数据类型
java中一共就8种基本类型。
整数类型：byte、short、int、long。——装整数的
short：在java中不推荐用，在java中留着short仅仅是为了和别的语言做兼容，比如C语言中有short
浮点型：float、double。——装小数的
float：也是不推荐用的，也是为了和别的语言兼容的。
这8种基本数据类型，每种数据类型所占用的内存空间大小是不同的。
电脑上内存占用越大，则电脑跑的越慢，所以选择数据类型的时候，够用就行，能用4个字节就不用了8个字节。
对于字节的概念
1G=1024M(兆)
1M=1024KB(千字节)
1KB=1024B(字节)
1B=8Bit(位) （Bit是最小单位，记的时候，记到字节就可以了）
1G=1024×1024×1024字节-------1073741824字节（10亿多个字节）
知道字节了，想知道占了多少位，就乘以8就行了，反之，想知道多少字节，就除以8就行了
| 数据类型 | 字节 | 占位 | 范围 | 默认值 |
|---|---|---|---|---|
| 字节型：byte | 1字节 | 8位 | -128~127 | 0 |
| 短整型: short | 2字节 | 16位 | -32768（-215）~32767（215 - 1） | 0 |
| 整型:int | 4字节 | 32位 | （-231）~（231 - 1） | 0 |
| 长整型: long | 8字节 | 64位 | （-263）~（263 -1） | 0L |
| 单精度浮点型: float | 4字节 | 32位 | 1.4E-45~3.4028235E38 | 0.0f |
| 双精度浮点型:double | 8字节 | 64位 | 4.9E-324~1.7976931348623157E308 | 0.0d |
| 字符型：char | 2字节 | 16位 | ‘ \u0000（0）~u\ffff ’（65535） | ‘\u0000 ’ |
| 布尔型：boolean | 1字节 | 8位 | true/false | false |
byte：字节型
• byte数据类型是8位、有符号的，以二进制补码表示的整数；
• 最小值是-128（-2^7）；
• 最大值是127（2^7-1）；
• 默认值是0；
• byte类型用在大型数组中节约空间，主要代替整数，因为byte变量占用的空间只有int类型的四分之一；
• 例子：byte a = 100，byte b = -50。
short：短整型
• short数据类型是16位、有符号的以二进制补码表示的整数
• 最小值是-32768（-2^15）；
• 最大值是32767（2^15 - 1）；
• Short数据类型也可以像byte那样节省空间。一个short变量是int型变量所占空间的二分之一；
• 默认值是0；
• 例子：short s =1000，short r = -20000。
int：长整型
• int数据类型是32位、有符号的以二进制补码表示的整数；
• 最小值是-2,147,483,648（-2^31）；
• 最大值是2,147,485,647（2^31 - 1）；
• 一般地整型变量默认为int类型；
• 默认值是0；
• 例子：int a =100000, int b = -200000。
1)int:整型，4个字节，-21个多亿到21个多亿
1.1)整数直接量默认为int，但不能超范围，若超范围则编译错误；
1.2)两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)；
1.3)整数运算时，若超范围则发生溢出，溢出是需要避免的；
ps：直接量：直接写出来的数。
整数直接量（literal）：直接写出来的整数。
关于编译错误和溢出：
直接量超范围为编译错误，运算时超范围为溢出
int a = 10000000000; //编译错误
int b = 1000000000*10; //溢出
溢出并不提示错误，但是数字不对了，所以溢出的现象要避免。
避免溢出，可能出现溢出情况，则不用int，用long。
int balance = 2147483647;（balance ：余额）
balance = balance+1;
System.out.println(balance); //-2147483648
int：最大值+1溢出，变成最小值，最小值溢出，变成最大值。
long：长整型
• long数据类型是64位、有符号的以二进制补码表示的整数；
• 最小值是-9,223,372,036,854,775,808（-2^63）；
• 最大值是9,223,372,036,854,775,807（2^63 -1）；（19位：百万万亿）
• 这种类型主要使用在需要比较大整数的系统上；
• 默认值是0L；
• 例子： long a =100000L，int b = -200000L。
2)long:长整型，8个字节，很大很大很大
2.1)长整型的直接量需在数字后加L或l，建议写大写的L；
比如：long a = 10000000000;这样是报编译错误的，和前面的long无关，100亿这个数直接这么写就是报错，因为100亿默认是int，这样写超范围了，所以要在后面加上L，即long a = 10000000000L;
2.2)运算时若有可能溢出，建议在第1个数字加L；如果不加L，也不报错，但是数字默认还是int，超范围则数字变了。 运算时如果多种类型参与，系统会往大的类型转。
比如：如果在最后一个数字上写L：
long a = 1000000000*2*10L;
System.out.println(a);//20000000000
1000000000是int类型，2也是int类型，结果2000000000也是int类型，200亿在int范围内，无影响，最后乘以10L，告诉计算机是long类型，最后结果是200亿，对结果无影响；
但是：
long b = 1000000000*3*10L;
System.out.println(b); //不是300亿，是-12949672960
如果这样，1000000000是int类型，3也是int类型，结果300亿是int类型却超出了int范围，则溢出，结果变化，最后结果是-12949672960；
所以要在第一个数字后加L，在前面就告诉计算机是long类型，如下：
long a = 1000000000L*2*10;
System.out.println(a); //200亿
long b = 1000000000L*3*10;
System.out.println(b); //300亿
2.3)System.currentTimeMillis()用于获取自1970.1.1零时到此时此刻的毫秒数；
long有一个应用：JDK提供System.currentTimeMillis()方法，返回1970年1月1日零点到此时此刻所经历的毫秒数，其数据类型为long，该方法经常用于计时操作，比如连续用两次这个方法，求差，就能得到想知道的时间。
（1970年1月1日零点是统一定的原点，其他语言也是这个）
long time = System.currentTimeMillis();
System.out.println(time+"毫秒");
//1588993185992毫秒
float：单精度浮点型
• float数据类型是单精度、32位、符合IEEE 754标准的浮点数；
• float在储存大型浮点数组的时候可节省内存空间；
• 默认值是0.0f；
• 浮点数不能用来表示精确的值，如货币；
• 例子：float f1 =234.5f。
因为默认的浮点型直接量是double型，如果需要表示float类型的直接量，需要加f或F后缀，例如：float f1=3.14;会有编译错误，应该写成float f1=3.14f;
double：双精度浮点型
• double数据类型是双精度、64位、符合IEEE 754标准的浮点数；
• double类型的精度值是float的两倍，这也正是其名称双精度的来由。
小数点后面的尾数越长，意味着精确度越高。
• 浮点数的默认类型为double类型；一般就用double了，不用float；
• double类型同样不能表示精确的值，如货币；
• 默认值是0.0f；
• 例子：double d1 =123.4。
3)double:浮点型，8个字节，很大很大很大
3.1)浮点数直接量默认为double型，表示float需在数字后加F或f
浮点型的直接量有两种写法：
—通常写法，如3.14、314.0、0.1、.5。
—科学计数法（一般不这么写），如：1.25E2、1.25e2、1.25E-2。其中1.25E2表示1.25乘以10的2次方，即125.0。
3.2)double与float型数据在参与运算时，有可能会出现舍入误差。
2进制系统中无法精确的表示1/10，就像十进制系统中无法精确的表示1/3一样，所以，2机制表示10进制会有一些舍入误差，对于一些要求精确运算的场合会导致代码的缺陷，比如银行等，
在二进制中有一些数是无法精确表示的，同理，在十进制中也有一些数无法精确表示。
java代码都是用的十进制，最后编译运行时一定要变成二进制0和1的。
十进制：在十进制中：
1/10------------0.1 精确数字
1/2-------------0.5 精确数字
1/3-------------0.333333333… 非精确数字
2/3-------------0.666666666… 非精确数字
二进制：逢2进1，只认0和1
1/10------------非精确数字
比如：下面这两个例子都是无限接近，但是不是，这就是误差，这个误差是有可能发生，有可能不发生的。
double a=3.0,b=2.9;
System.out.println(a-b); //0.10000000000000009
//不是0.1
double a=6.0,b=4.9;
System.out.println(a-b); //1.09999999999999996
//不是1.1
double a=6.0,b=2.9;
System.out.println(a-b);//结果是3.1，没有误差
但是误差不能出现，所有有时候精确运算时不能选择double或者float，比如财务ERP（ERP是企业资源规划，一般是集团性质的公司）------------BigDecimal，也是存小数的，是可以精确表示的。
int和double一起计算，只要有double参与，最后就会转成double。
//整数相除，小数直接舍弃
System.out.println(5/2);
System.out.println(2/5);
//想要小数，有一位是小数就行了，系统会自动往大类型转
System.out.println(2.0/5);
System.out.println(2/5.0);
char：字符型
• char类型是一个单一的16位Unicode字符；是Character（：字符）的缩写。字符类型事实上是一个占用2个字节的无符号整数。
无符号：没有负数，只有0和正数。
有符号：有负数、有0、有正数。
• 最小值是’\u0000’（即为0）；
• 最大值是’\uffff’（即为65,535）；
• char数据类型可以储存任何字符；
• 例子：char letter= ‘A’。
5)char:字符型，2个字节
5.1)采用Unicode字符集编码，每个字符都有一个对应的码。Unicode：统一码、通用码、万国码。
表现的形式是字符char，但本质上是整数int(0到65535)。即看到的是符号，但是本质上计算机内部传输的是int。 int整数对应的——char的字符。
(ASCII码（阿斯科码）: ‘a’–97 ‘A’–65 ‘0’–48)
5.2)字符直接量需放在单引号中，只能有一个，不写也不行；
5.3)特殊字符需要 \ 来转义，比如char c = '\'';
在对char型变量赋值时，可以采用如下三总方式：
—1.字符直接量：形如：char a =‘A’；,变量中实际储存的是该字符的Unicode编码（无符号整数值），一个char型变量只能存储一个字符。
—2.整型直接量：范围在0~65535之间的整数，变量中实际存储的即该整数值，但表示的是该整数值所对应的Unicode字符。形如：char d = 65;//A
—Unicode形式：形如’\u0041’，Unicode字符的16进制形式。形如：char c =’\u0041’;
char c1 = '女';//字符女
char c2 = 'f';//字符f
char c3 = '6';//字符6，注意字符6和6不是一个意思
char c4 = ' ';//空格符
System.out.println(c1);//女
System.out.println(c2);//f
System.out.println(c3);//6
System.out.println(c4);//输出：空格
char c5 = '';//编译错误，不可以什么都不写，必须有字符
char c6 = '女性';//编译错误，不能写两个字符
char c7 = 65;//0到65535之间
System.out.println(c7);//输出：A
Java语言支持一些特殊的转义字符序列。
| 符号 | 字符含义 |
|---|---|
| \n | 换行 (0x0a) |
| \r | 回车 (0x0d) |
| \f | 换页符(0x0c) |
| \b | 退格 (0x08) |
| \s | 空格 (0x20) |
| \t | 制表符 |
\" |
双引号 |
\' |
单引号 |
\\ |
反斜杠 |
| \ddd | 八进制字符 (ddd) |
| \uxxxx | 16进制Unicode字符 (xxxx) |
boolean：布尔型
• boolean数据类型表示一位的信息；
• 只有两个取值：true和false；true和false都是布尔型的直接量；
• 这种类型只作为一种标志来记录true/false情况；
• 默认值是false；
• 例子：boolean one= true。
4)boolean:布尔型，1个字节
4.1)只能赋值为true或false。它的默认为false 。
3.基本数据类型间的转换:
类型转换不涉及boolean，但有char，char本质上是int，是数字。
数据类型从小到大依次为:
byte,short,int,long,float,double
char 可以转换成int。
小数类型比整数类型要大，因为除了有整数位还有小数位。
多种基本类型参与的表达式运算中，运算结果会自动的向较大的类型进行转换。
1)两种方式:
1.1)自动类型转换(隐式类型转换):小类型到大类型
1.2)强制类型转换:大类型到小类型：前面要加：(要转换成为的数据类型)变量
强转有可能溢出或丢失精度，比如double强转成float，也会造成精度的丢失。
int a = 3;
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 = 23.987;
int i = (int) h;
System.out.println(i);//23
//强转有可能会发生精度丢失，因为int没有小数
//但是自动类型转换不会发生溢出和精度丢失
double pi = 3.14159265358979323;
float f = (float) pi;//会造成精度的丢失
System.out.println(f);//结果为：3.1415927，往上进了一位
//double——int，小数部分是无条件舍弃的
//dounle——float，最后一位小数是四舍五入的，但是不同的系统结果也可能不一样
2)两点规则（记住）:
2.1)整数直接量可以直接赋值给byte,short,char，但不能超范围。
整数直接量可以直接赋值给byte，即 byte b = 5;按理说是错误的，但是并不错误；
但是不能超范围，超范围要这样写：byte b = (byte) 129。
2.2)byte,short,char型数据参与运算时，Java机制会一律先将其转换为int再运算。
byte b1 = 5;
byte b2 = 6;
//5和6都属于直接量，可以直接赋值给byte
byte b3 = b1+b2;//因为参与运算，系统会一律先将其转换为int再运算，所以报错
//要这样写：
byte b3 = (byte)(b1+b2);
//不能这样写：
byte b3 = (byte)b1+b2;
//因为强转的优先级最高，这样写不是在转b1+b2的和，而是在转b1，所以要给b1+b2加括号。
2.3)补充：为什么byte = 3 + 4；又不会报错？
因为：3+4是常量的计算，会优先执行，执行结果再赋值给byte，此时就和第一点原则一样，此时判断数值是否满足该类型范围，满足就直接赋值了。
所以，关于变量和常量计算（相加）：
两个变量相加，先对类型进行提升，然后运算，再将运算结果赋值。
两个常量相加，先计算常量数值，然后判断是否满足类型范围，再赋值。
2.4）补充：char型数据参与运算时：
System.out.println(2+2);//4
System.out.println('2'+'2');//100
/*
byte,short,char型数据参与运算时，Java机制会一律先将其转换为int再运算
知道：'a'--97 'A'--65 '0'--48，所以'2'=50
所以50+50是100
*/
4.Scanner的用法:
是java提供的小零件，有很多的功能。
给变量赋值:
1)赋一个固定的值:
int a = 250;
2)接收用户输入的值:-------------Scanner
int a = ?;
3)系统随机生成的值:
int a = ?;
package package01;
import java.util.Scanner;//第1步,在package下导包
/**
* @author Charles
* @date 2020/5/11 - 10:49
* Scanner的演示
*/
public class ScannerDemo {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);//第2步
System.out.println("请输入年龄：");//在让用户输入之前，起到提示作用，一般情况下都要有这句话
int age = scan.nextInt();//第3步:代码走到这里，系统就会等待用户输入，输入的值赋值给age
//这3步就是通过用户给age赋值
System.out.println(age);
System.out.println("请输入价格：");
double price = scan.nextDouble();
System.out.println(price);
}
}
3.运算符和表达式、分支结构（上）
小节：
1.运算符6组:
运算的符号，除了一些语句、数字、变量等，都是符号。而表达式是运算符连接起来的。
-
算术运算符7个:
+,-,*,/,%,++,---
%:取模/取余，余数为0即为整除
-
++/–:自增1/自减1，可在变量前也可在变量后
-
单独使用时，在前在后都一样
-
被使用时，在前在后不一样
-
a++的值为a-------(a–的值为a)
-
++a的值为a+1-----(–a的值为a-1)
-
int a=5,b=5; //1)输出a--的值5 //2)a自减1变为4 System.out.println(a--); //5 System.out.println(a); //4 //1)输出--b的值4 //2)b自减1变为4 System.out.println(--b); //4 System.out.println(b); //4
-
-
-
int a=5,b=5; //1)将a++的值5赋值给c //2)a自增1变为6 int c = a++; //1)将++b的值6赋值给d //2)b自增1变为6 int d = ++b; System.out.println(a); //6 System.out.println(b); //6 System.out.println(c); //5 System.out.println(d); //6
-
-
关系运算符:
>,<,>=,<=,==,!=最终的运算结果都是boolean。>(大于),<(小于)- ``>=(大于或等于),<=(小于或等于)`
- ==(等于),!=(不等于)
- 关系运算的结果为boolean型，关系成立则为true，关系不成立则为false。
-
逻辑运算符:
&&,||,!最终的运算结果都是boolean-
&&:短路与(并且)，两边都为真则为真，见false则false，当第一个数为false时，则发生短路(后面的不执行了)。
-
||:短路或(或者)，有一边为真则为真，见true则true，当第一个数为true时，则发生短路(后面的不执行了)。
-
!:逻辑非(取反)，非真则假，非假则真。
-
逻辑运算是建立在关系运算的基础之上的，逻辑运算的结果为boolean型。
-
int a=5,b=10,c=5; //&&:短路与(并且)，第一个数为false时，则后面的不执行。 boolean b3 = a>b && c++>2; System.out.println(b3); //false System.out.println(c); //5，发生短路了 //||:短路或(或者)，第一个数为true时，则后面的不执行。 boolean b4 = a<b || c++>2; System.out.println(b4); //true System.out.println(c); //5，发生短路了
-
-
赋值运算符:
=,+=,-=,*=,/=,%=一个=是赋值操作。-
简单赋值运算符:=
-
扩展赋值运算符:+=,-=,*=,/=,%=。扩展赋值运算自带强转功能。
-
int a = 5; a += 10; //相当于a=(int)(a+10) System.out.println(a); //15 a *= 2; //相当于a=a*2 System.out.println(a); //30 a /= 6; //相当于a=a/6 System.out.println(a); //5 -
//面试题:如下3句话，哪句话会出现错误，为什么？怎么改？ short s = 5; s += 10; //相当于s=(short)(s+10); //s = s+10; //编译错误，需要强转--s = (short)(s+10);
-
-
字符串连接运算符:+。
- 若两边为数字，则做加法运算。
- 若两边出现了字符串，则做字符串连接。
-
条件/三目运算符: boolean?数1:数2。
-
语法：boolean?数1:数2
-
执行过程：计算boolean的值:
-
若为true，则整个表达式的结果为数1。
-
若为false，则整个表达式的结果为数2。
-
int a=8,b=55; int max = a>b?a:b; //找到a和b中的最大值 System.out.println("max="+max);
-
-
条件控制：关系运算符和逻辑运算符
若想干某件事是由一个条件控制的-----------关系运算符
成绩>=60
若想干某件事是由多个条件控制的-----------逻辑运算符
成绩>=60 并且 出勤率>=80%
2.分支结构:
1)if结构:1条路
2)if…else结构:2条路
满足条件就干事，不满足条件则不干事-------if
满足条件就干事，不满足条件干另一个事-----if…else
闰年的判断公式:
1)能被4整除，并且，不能被100整除
或者
2)能被400整除
1)year%40 && year%100!=0
||
2)year%4000
(year%40 && year%100!=0) || year%4000
package day03;
import java.util.Scanner;
//闰年判断程序
public class LeapYear {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
System.out.println("请输入年份:");
int year = scan.nextInt();
boolean flag = (year%4==0 && year%100!=0)
||
year%400==0;
//用三目运算符来判断的：
String str = flag ? year+"是闰年" : year+"不是闰年";
System.out.println(str);
}
}
char和String
字符char:单引号中，只有1个
字符串String:双引号中，0个到多个
变量的作用域/范围：
从变量的声明开始，到包含它的最近的大括号结束
4.分支结构（上）、循环结构（下）
1.求两个数中的最大值：
//1.求两个数中的最大值:
int a=8,b=55;
int max = a>b?a:b;
System.out.println("max="+max);
2.两个数的排序：
//2.两个数的排序:
int a=8,b=55; //升序
if(a>b) {//基于条件执行：当a>b时则交换，保证a
int t=a;
a=b;
b=t;
}
System.out.println(a);
System.out.println(b);
//b是想要a修改之前的数，所以在a修改之前，把a的值先存到t里，t=8。
//总结：交换两个数的常规写法：
//int t=a;a=b;b=t; 追尾并绕圈 只要没追尾，一定是错的。
3.三个数的排序：
/**三个数排序，要保证a是最小的：
若a>b则交换，保证ac则交换，保证ac则交换，保证b
//3.三个数的排序:
int a=8,b=2,c=5;
if(a>b) {
int t=a;
a=b;
b=t;
}
if(a>c) {
int t=a;
a=c;
c=t;
}
if(b>c) {
int t=b;
b=c;
c=t;
}
System.out.println(a);
System.out.println(b);
System.out.println(c);
/**四个数判断排序 少量数据可以这样排序，大量数据排不了
* int a=8,b=2,c=5,d=1; //升序(a=2,b=5,c=8)
若a>b则交换，保证ac则交换，保证ad则交换，保证ac则交换，保证bd则交换，保证bd则交换，保证c
4.闰年的判断
//4.闰年的判断
int year = 2001;
if((year%4==0 && year%100!=0) || year%400==0) {
System.out.println(year+"是闰年");
}else {
System.out.println(year+"不是闰年");
}
5.变量的作用域与重名问题
* 1)变量的作用域/范围:
* 从变量的声明开始，到包含它最近的大括号结束
- 2)变量的重名问题:
* 作用域重叠时，变量不能重名
int a=5;
if(a>2) {
//int a=55; //作用域重叠了，变量不能重名
int b=8;
}else {
int b=10;
}
int a=5;
if(a>2) {
int b=6;
System.out.println(a);
System.out.println(b);
}
System.out.println(a);
//System.out.println(b); //编译错误，超出作用范围了
小节：
1.分支结构:
3)if…else if结构:多条路
4)switch…case结构:多条路。
优点:效率高、结构清晰。缺点:整数、相等。
break:跳出switch
对整数判断相等，首选switch case。
switch后的括号内，可以是byte,short,int,char,String(jdk1.7开始支持)。
package day04;
//分支结构的演示
public class ConditionDemo {
public static void main(String[] args) {
int num = 6;
switch(num) { //byte,short,int,char,String(jdk1.7开始支持)
case 1: //相当于if(num==1)
System.out.println(111);
break;
case 2: //以此为入口
System.out.println(222);
break; //跳出switch
case 3:
System.out.println(333);
break;
default: //所有case都未匹配时执行
System.out.println(666);
}
}
}
任何复杂的程序逻辑都可以通过三种结构来实现:
1)顺序结构:从上往下逐行执行，每句必走
2)分支结构:有条件的执行某语句一次，并非每句必走
3)循环结构:有条件的执行某语句多次，并非每句必走
if(boolean){ //一次
语句块
}
while(boolean){ //多次
语句块
}
2.循环:反复执行一段相同或相似的代码
3.循环三要素:
1)循环变量的初始化；
2)循环的条件(以循环变量为基础)；
3)循环变量的改变(向着循环的结束变)；
循环变量:在整个循环过程中所反复改变的那个数。
4.循环结构:
1)while:先判断后执行，有可能一次都不执行
2)do…while:先执行后判断，至少执行一次。要素1与要素3相同时，首选do…while。
1.输出10次"行动是成功的阶梯"
int times=0; //1)循环变量的初始化
while(times<10) { //2)循环的条件
System.out.println("行动是成功的阶梯");
times++; //3)循环变量的改变
}
System.out.println("over");
/*
* 执行过程:
* times=0
* true 输出 times=1
* true 输出 times=2
* true 输出 times=3
* true 输出 times=4
* true 输出 times=5
* true 输出 times=6
* true 输出 times=7
* true 输出 times=8
* true 输出 times=9
* true 输出 times=10
* false while循环结束
* 输出over
*/
2.输出9的乘法表:
- 1)正序(1到9)
- 2)倒序(9到1)
- 3)奇数(1/3/5/7/9)
//正序(1到9)
int num=1;
while(num<=9) {
System.out.println(num+"*9="+num*9);
num++;
}
//倒序(9到1)
int num=9;
while(num>=1) {
System.out.println(num+"*9="+num*9);
num--;
}
//奇数(1/3/5/7/9)
int num=1;
while(num<=9) {
System.out.println(num+"*9="+num*9);
num+=2;
3.猜数字小游戏
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);
//1)do..while语法 2)三要素(改错) 3)Ctrl+C/V 4)改else if
int guess;
do {
System.out.println("猜吧!");
guess = scan.nextInt(); //1+3
if(guess==0) {
break;
}
if(guess>num) {
System.out.println("太大了");
}else if(guess<num){
System.out.println("太小了");
}
}while(guess!=num); //2
if(guess==num) {
System.out.println("恭喜你，猜对了!");
}else {
System.out.println("下次再来吧!");
}
/*
System.out.println("猜吧!");
int guess = scan.nextInt(); //1.
while(guess!=num) { //2.
if(guess==0) {
break;
}
if(guess>num) {
System.out.println("太大了");
}else {
System.out.println("太小了");
}
System.out.println("猜吧!");
guess = scan.nextInt(); //3.
}
if(guess==num) {
System.out.println("恭喜你，猜对了!");
}else {
System.out.println("下次再来吧!");
}
*/
}
}
5.循环结构（下）、数组（上）
回顾
1.分支结构:
3)if…else if:多条路
4)switch…case:多条路
优点:效率高、结构清晰
缺点:整数、相等。当缺点不是缺点的时候，就是优点了。
break:跳出switch
2.循环:反复执行一段相同或相似的代码
3.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量:在循环过程中所反复改变的那个数
4.循环结构:
1)while:先判断后执行，有可能一次都不执行
2)do…while:先执行后判断，至少执行一次
要素1与要素3相同时，首选do…while
实例：
1.根据年份和月份，计算天数
2.个人所得税
package day05;
public class Homework {
public static void main(String[] args) {
//2.根据年份和月份，计算天数
int year = 2001; //年份
int month = 5; //月份
int days = 0; //天数
switch(month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
days = 31;
break;
case 4:
case 6:
case 9:
case 11:
days = 30;
break;
case 2:
if((year%4==0 && year%100!=0) || year%400==0) {
days = 29;
}else {
days = 28;
}
}
System.out.println("days="+days);
//1.个人所得税:
double salary = 10000.0; //工资
double taxSalary = salary-3500; //计税工资
double tax = 0.0; //税
if(taxSalary<=0) {
tax = 0.0; //不纳税
}else if(taxSalary<=1500) {
tax = taxSalary*0.03-0;
}else if(taxSalary<=4500) {
tax = taxSalary*0.1-105;
}else if(taxSalary<=9000) {
tax = taxSalary*0.2-555;
}
System.out.println("tax="+tax);
小节：
1.for循环
- for:应用率最高，与次数有关的循环（要知道循环多少次）。
- 猜数字不能用for循环，因为不知道要猜多少次。
- for (int i = 0要素1; i < args.length要素2; i++要素3) {
语句块
}
// 1 2 3
for(int times=0 ; times<10 ; times++){
System.out.println(“行动是成功的阶梯”); //4
}
【循环顺序】124 324 324 …32,到2结束。
int times=0; //1.
while(times<10) { //2.
System.out.println(“行动是成功的阶梯”); //4.
times++; //3.
}
【循环顺序】12432432432432432432
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次
int a = (int)(Math.random()*100); //0到99之间
int b = (int)(Math.random()*100); //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);
}
}
2.注意事项
- for 和 while 编号看循环，都是12432432432，以2为结尾
- for 里面的变量，范围仅仅在自己的for里面用，与之前大括号的作用域不用，是唯一特殊的。
- 如果要在外面用【变量】，就【先声明，后初始化】。
- 写for的1+2+3+4+…+99+100=？代码结合了前面的2与3点，写的累加求和,先在for前面设一个声明初始化sum总数，在for后面写一个输出语句syso，语句块位置用的是 sum=sum+num；并写出执行过程。
- for循环特殊的格式：for中的三个分号必不可少。中间的条件不能用逗号隔开，要用逻辑运算符与&&、或||。
3.break和continue
-
break：跳出（终止）循环 （一定会用）
- break可用于循环语句或者switch case语句
- 常常和条件语句if一起用，在某种特定条件下来跳出循环。
- 【循环结束2种情况】：条件为假，break
-
continue：跳过循环体中剩余语句而进入下一次循环
-
continue只会在循环中用，这个关键词比较可有可无。（不一定用）
-
2个对比的例子，累加1到100的和，跳过个位为3的
-
【用continue的情况】 //累加1到100的和，跳过个位为3的 int sum = 0; //存和 for(int num=1;num<=100;num++) { if(num%10==3) { continue; //跳过循环体中剩余语句而进入下一次循环 } sum += num; } System.out.println("sum="+sum); -
【不用continue的情况】 //累加1到100的和，只要个位不为3的 int sum = 0; //存和 for(int num=1;num<=100;num++) { if(num%10!=3) { sum += num; } } System.out.println("sum="+sum);
-
-
for循环的演示：
package day05;
//for循环的演示
public class ForDemo {
public static void main(String[] args) {
for(int i=1,j=6;i<=5;i+=2,j-=2) {
}
/*
* i=1,j=6
* i=3,j=4
* i=5,j=2
* i=7,j=0
*/
//无限循环："我要学习..."
for(;;) {
System.out.println("我要学习...");
}
//累和:1+2+3+4+...+99+100=?
int sum = 0; //存和
for(int num=1;num<=100;num++) {
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=100 sum=1+2+3+4+...+100
* num=101
*/
//累加1到100的和，只要个位不为3的
int sum = 0; //存和
for(int num=1;num<=100;num++) {
if(num%10!=3) {
sum += num;
}
}
System.out.println("sum="+sum);
//累加1到100的和，跳过个位为3的
int sum = 0; //存和
for(int num=1;num<=100;num++) {
if(num%10==3) {
continue; //跳过循环体中剩余语句而进入下一次循环
}
sum += num;
}
System.out.println("sum="+sum);
/*
* sum=0
* num=1 sum=1
* num=2 sum=1+2
* num=3
* num=4 sum=1+2+4
*/
}
}
4.三种循环结构的更佳适用情况
1）while：“当...”
2）do...while：“直到...”
要素1与要素3相同时首选do...while
3)for：与次数相关的
5.循环结构的选择:
1.先看是否与次数相关?
1)与次数相关----------直接上for
2)与次数无关，再看要素1与要素3是否相同?
2.1)若相同----------直接上do…while
2.2)若不同----------直接上while
6.嵌套循环: 循环可以随便套
1)循环中套循环，一般多行多列时使用，外层控制行，内层控制列
2)执行规则:外层循环走一次，内层循环走所有次
3)建议:嵌套层次越少越好，能用一层就不用两层，能用两层就不用三层
当业务需求必须通过三层以上的循环来解决，说明设计有问题
4)break只能跳出一层循环
九九乘法表
package day05;
//九九乘法表
public class MutilTable {
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");//\t转义符 水平制表位 固定占8位
}
System.out.println(); //换行
}
/*
* 执行过程:
* num=3
* i=1 1*3=3
* i=2 2*3=6
* i=3 3*3=9
* i=4
* 换行
* num=2
* i=1 1*2=2
* i=2 2*2=4
* i=3
* 换行
* num=1
* i=1 1*1=1
* i=2
* 换行
*/
}
}
5.程序=算法+数据结构
1)算法:解决问题的流程/步骤(顺序、分支、循环)
2)数据结构:将数据按照某种特定的结构来保存
设计良好的/合理的数据结构会导致好的算法
6.数组:
1)相同数据类型元素的集合
2)是一种数据类型(引用类型)
3)数组的声明:
int[] arr = new int[10]; 声明整型数组，内含十个元素
（int arr[]是C语言的写法）
4)数组的初始化:
int[] arr = new int[4]; //0,0,0,0 【**只要写new了，就有默认值了，元素都是0**】
int[] arr = {1,4,7,9}; //1,4,7,9 可以这样写，但是不能分着写
int[] arr = new int[]{1,4,7,9}; //1,4,7,9 可以分着写
//分开写是这样的：
int[] arr;
arr = new int[]{1,4,7,9}; //正确
5)数组的访问:
5.1)通过(数组名.length)可以获取数组的长度(数组元素的个数)
int[] arr = new int[4];
System.out.println(arr.length); //4
5.2)通过下标/索引来访问数组中的元素
//【下标从0开始，最大到(arr.length-1)】
int[] arr = new int[3];
arr[0] = 100; //给arr中的第1个元素赋值为100，【为int类型】
arr[1] = 200; //给arr中的第2个元素赋值为200
arr[2] = 300; //给arr中的第3个元素赋值为300
arr[3] = 400; //发生数组下标越界异常
System.out.println(arr[arr.length-1]); //输出数组中最后一个元素的值
6)数组的遍历:
int[] arr = new int[10];
for(int i=0;i<arr.length;i++){//【注意：中间长度这里永远不要写死】
arr[i] = 100;
}
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);
}
for(int i=arr.length-1;i>=0;i--){
System.out.println(arr[i]);
}
数组的练习：
/*
* 数组的练习:
* 1)声明整型数组arr1，包含10个元素
* 2)声明整型数组arr2，并直接给元素赋值为2,5,8
* 声明整型数组arr3，先new再直接给arr3赋值为为2,5,8
* 3)声明整型数组arr，包含3个元素
* 输出arr的长度
* 给arr中第1个元素赋值为100
* 给arr中第2个元素赋值为200
* 给arr中第3个元素赋值为300
* arr[3] = 400;------------------???
* 输出arr中最后一个元素的值(下标不能写死)
* 4)声明整型数组as，包含10个元素
* 遍历as，给每个元素赋值为0到99之间的随机数
* 遍历as，输出每个元素的值
*/
计算机的最高奖项：图灵奖
程序=算法+数据结构
1）算法：解决问题的流程
2）数据结构：设计数据结构------算法
【前三个点是必须要掌握的，最基础的】
//1.数组的定义
int[] arr1 = new int[10];
//2.数组的初始化
int[] arr2 = new int[4]; //0,0,0,0
int[] arr3 = {1,3,5,7}; //1,3,5,7
int[] arr4 = new int[] {1,3,5,7}; //1,3,5,7
int[] arr5;
//arr5 = {1,3,5,7}; //编译错误，此写法只能声明同时初始化
arr5 = new int[] {1,3,5,7}; //正确
//3.数组的访问
int[] arr6 = new int[3];
System.out.println(arr6.length); //3
arr6[0] = 100; //给arr6中的第1个元素赋值为100
arr6[1] = 200;
arr6[2] = 300;
//arr6[3] = 400; //数组下标越界异常
System.out.println(arr6[arr6.length-1]); //输出最后一个元素的值
//4.数组的遍历
int[] arr = new int[10];
for(int i=0;i<arr.length;i++) { //遍历arr数组
arr[i] = (int)(Math.random()*100);
}
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
6.数组（下）、方法
回顾:
1.循环结构:
3)for:应用率高，与次数相关的
2.break:跳出循环
continue:跳过循环体中剩余语句而进入下一次循环
3.适用情况:
1)与次数相关------for
2)与次数无关:
2.1)要素1与要素3相同------do…while
2.2)要素1与要素3不同------while
4.嵌套循环:
5.数组:
1)相同数据类型元素的集合
2)是一种数据类型(引用类型)
3)int[] arr = new int[10];
4)int[] arr = new int[3]; //0,0,0
int[] arr = {1,4,6}; //1,4,6
int[] arr = new int[]{1,4,6}; //1,4,6
5)int[] arr = new int[3];
arr[0] = 100;
arr[2] = 300;
System.out.println(arr[arr.length-1]);
6)for(int i=0;i
System.out.println(arr[i]);
}
int num=0;
while(num<10){
num++;
}
System.out.println(num); //10
int num;//先声明
for(num=0;num<10;num++){//因为num只能在for里面用
}
System.out.println(num); //10
实例
package day06;
public class Homework {
public static void main(String[] args) {
//1/1+1/2+1/3+1/4+...+1/n=?
int n = 15;
double sum = 0; //存和
for(int i=1;i<=n;i++) { //n次
sum += 1.0/i;
}
System.out.println("sum="+sum);
/*
//累加和:9+99+999+9999+...+9999999999=?
long sum = 0; //存和
long num = 0; //加数
for(int i=1;i<=10;i++) { //10次
num = num*10+9;
sum = sum+num;
}
System.out.println("sum="+sum);
*/
/*
* sum=0 num=0
* i=1 num=9 sum=9
* i=2 num=99 sum=9+99
* i=3 num=999 sum=9+99+999
* i=4 num=9999 sum=9+99+999+9999
* ...
* i=10 num=9999999999 sum=9+99+999+9999+...+9999999999
* i=11
*/
/*
* num=0 num=num*10+9
* i=1 num=9 num=0 *10+9
* i=2 num=99 num=9 *10+9
* i=3 num=999 num=99 *10+9
* i=4 num=9999 num=999 *10+9
* i=5 num=99999 num=9999 *10+9
*/
}
}
小节：
1.数组:
1)数组的复制:2种方式
1.1)灵活复制：【System.arraycopy(a,1,a1,0,4);】
优点：灵活性好，效率高
int[] a = {10,20,30,40,50};
int[] a1 = new int[6]; //0,0,0,0,0,0
//a:源数组
//1: 源数组的起始下标
//a1:目标数组
//0:目标数组的起始下标
//4:要复制的元素个数
System.arraycopy(a,1,a1,0,4); //灵活性好，效率高
for(int i=0;i<a1.length;i++) {
System.out.println(a1[i]);
}
1.2)整体复制，多补少截：【int[] a1 = Arrays.copyOf(a,6);】
/*
int[] a = {10,20,30,40,50};
//a:源数组
//a1:目标数组
//6:目标数组的长度(多则补默认值，少则截取)
int[] a1 = Arrays.copyOf(a,8);
for(int i=0;i
数组的扩容：【a = Arrays.copyOf(a,a.length+1);】
/*
int[] a = {10,20,30,40,50};
//数组的扩容(创建了一个新的数组并将原数组数据复制过去)
a = Arrays.copyOf(a,a.length+1);//加1一个位置
for(int i=0;i
2)数组的排序:
2.1)Arrays.sort(arr);
//6.数组的排序:可用【long a=System.currentTimeMillis();】判断哪种生序快。
int[] arr = {35,47,2,15,32};
Arrays.sort(arr); //升序（只有升序）
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
找最大值算法:
int[] arr = {12,25,46,5};
1)假设第1个元素为最大值:
int max = arr[0];
2)遍历剩余元素，若剩余元素大于max，
则修改max的值为较大的数
for(int i=1;i
max=arr[i];
}
}
max=56/78/89
package day06;
import java.util.Arrays;
//1.求数组元素的最大值
//2.并将最大值放在数组最后一个元素的下一个位置
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; //将最大值放在最后一个元素上
for(int i=0;i<arr.length;i++) {
System.out.println(arr[i]);
}
}
}
2.方法：
2.方法:函数、过程。 各种语言都有方法，C语言的方法叫函数，要掌握如何自己写方法。
1)封装一段特定的业务逻辑功能
2)方法尽可能的独立，一个方法只干一件事
3)方法可以被反复多次调用
4)减少代码的重复，有利于代码的维护，有利于团队的协作
3.方法的定义:
修饰词 返回值类型 方法名(参数列表){
方法体
}
4.方法的调用:
1)无返回值: 方法名(有参传参);
2)有返回值: 数据类型 变量 = 方法名(有参传参);
5.return:
1)return 值;
1.1)结束方法的执行
1.2)返回结果给调用方
2)return;
2.1)结束方法的执行