詹姆斯·高斯林（James Gosling）1977年获得了加拿大卡尔加里大 学计算机科学学士学位，1983年 获得了美国卡内基梅隆大学计算机科学博士学位，毕业后到IBM工作，设计IBM第一代工作站NeWS系统，但不受重视。
后来转至Sun公司，1990年，与Patrick，Naughton和Mike Sheridan等人合作“绿色计划”，后来发展一套语言叫做“Oak”，后改名为Java。
JAVA语言是Sun公司设计的一种面向对象程序设计语言。
oracle收购的sun公司
Java Development Kit （kit: 配套元件）
1.0 - 1.1 - 1.2 - 1.3 - 1.4 - 1.5
5.0 - 6.0 - 7.0 - 8.0……
Sun公司于1995年推出
1991年sun公司James Gosling等人开始开发Oak语言
1994年，将Oak语言更名为Java
1996年获得第一笔投资1亿元
1998年提出jdk1.2，更名为java2
之后推出jdk1.3 jdk1.4
2005年更名为jdk5.0，进行了大幅的版本改进
2006年sun公司宣布将Java作为免费软件对外发布
2007年3月起，全世界所有的开发人员均可对Java源代码进行修改
2007年推出jdk6.0
2009年4月Oracle(甲骨文)以74亿美元收购了sun公司
2011年7月由Oracle正式发布jdk7
2014年3月正式发布了java8
J2SE(Java 2 Platform Standard Edition)标准版初学者学的是SE）
是为开发普通桌面和商务应用程序提供的解决方案，该技术体系是其他两者的基础，可以完成一些桌面应用程序的开发。
J2ME(Java 2 Platform Micro Edition)小型版
是为开发移动设备和嵌入式设备(电器、机器人、机顶盒…)提供的解决方案。
J2EE(Java 2 Platform Enterprise Edition)企业版
是为开发企业环境下的应用程序提供的一套解决方案，该技术体系中包含的技术如 Servlet、Jsp等，主要针对于Web应用程序开发。可以做网站
注意：在JDK5.0时改名为javaSE,javaEE,javaME.
目前所学SE 。
简单性 高性能
编译性 解释性
面向对象 分布式处理
健壮性 安全性
开源 跨平台
什么是跨平台性？
通过Java语言编写的应用程序在不同的系统平台上都可以运行。
原理是什么？
只要在需要运行java应用程序的操作系统上，先安装一个Java虚拟机(JVM Java Virtual Machine)即可。由JVM来负责Java程序在该系统中的运行。
因为有了JVM，所以同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。也称为Java具有良好的可移植性。
JDK是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心。
它包含了:
1、JAVA开发工具(jdkbin)
2、基础开发库(jdkjrelibrt.jar)
3、基础开发库的源码(jdksrc.zip)
注意：jdk不要追求使用最新版本，因为企业围绕着java语言周边的生态都支持到了java版本，使用这个经过几年沉淀都稳定的版本，企业才会使用。因为企业追求的第一要素是稳。
通过官方网站获取JDK：http://www.oracle.com
也可以通过百度自行搜索资源。
下载（http://www.oracle.com(进入首页------最下方选择java SE14 download------最下方Java Archive-----根据不同版本的JavaSE,来选择对应的不同操作系统的jdk) 一般是下载同一个·版本中最后更新的版本。
Archive:档案文件
针对不同操作系统，下载不同的JDK版本 如：
如果你的计算机是Windows64位的 — x64;
Windows32位的 — i586
识别计算机的操作系统: 计算机------右键属性
Jre:JRE(Java Runtime Enviroment)是Java的运行环境。面向Java程序的使用者，而不是开发者。JRE是运行Java程序所必须环境的集合，包含JVM标准实现及 Java核心类库。它包括Java虚拟机、Java平台核心类和支持文件。它不包含开发工具(编译器、调试器等)。
Server JRE:是专为服务器端程序量身打造的, 只包含JRE/JDK中最常用的那部分功能.。为了做到简单，Server JRE不使用安装包, 而是一个绿色版的压缩文件。
针对不同操作系统，下载不同的JDK版本 如：
如果你的计算机是Windows64位的 — x64;
Windows32位的 — i586
识别计算机的操作系统: 计算机------右键属性
）
下载完后进行安装，傻瓜式安装，下一步下一步即可。
注意：
1、同时安装多个jdk时需要使用指定环境变量来确认使用的是哪个jdk
2、安装路径不要有中文或者特殊符号如空格等。最好目录统一
(我们一般最好将这些工具统一放到没有中文，没有空格的文件夹或目录中，注意：我们一般软件开发所使用到的软件，一般都要遵循这2个规则。)
3、我们也提供了绿色解压版，不需要安装直接解压即可
安装jdk之前一般在新建好的文件中建2个目录如：
Jdk1.8. 和jre1.8（可以建，因为jdk已经包含了jre.但是下载的是打包一起的安装包单独提供了jre.安装完后jdk后又会出现一个jre的安装提示框。所以安装它也没事，占不了多大的内存。当然也可以直接把jre提示框x掉。安装完后点击关闭按钮。）
至少2步JAVA_HOME和PATH
JAVA_HOME
该配置是要配置jdk的安装目录，来明确要使用哪个版本的jdk。
例如：我把jdk安装在了D:Javajdk7。配置如下：
用户变量：对当前用户起作用 （以前工作，电脑没普及，一个电脑几个人用，一个人一个账户需要配置自己的环境变量。所以用用户变量。）
系统变量：对所有的用户起作用。（现在一般使用用户变量）
新建--------JAVA_HOME(变量名)---------jdk安装的路径复制到这（变量值）----确定
PATH
系统会在path配置的值中，寻找可执行文件。
需要把jdkbin添加到path中。
Path—编辑—jdk安装的bin目录路径+；（英文）+jdk里面的jre中的bin目录的路径+;(英文) —确定 当然原来的第一个目录也可以删除。
在编程的领域中的符号都是英文状态。
注意：path里面的安装路径里的jdk安装路径，可以用%JAVA_HOME%
来代替.(bin保留。另一个是jrebin保留)。因为开始的都是jdk的安装目录，这样的好处是以后升级版本只需要改动JAVA_HOME里的路径，而path里的路径不用再改。一般推荐这种方法。
Jdk1.8开始自动生成环境变量，但一般不用，说一说我们自己配置的要放在它前面。
查看隐藏文件，计算机-----工具----文件夹选项-----查看—隐藏文件和文件夹进行勾选。
环境变量配置第3步：（可有可无，因为jdk1.6之后的版本可以省略。但是传统的习惯是配置的，不怕一万就怕万一。）环境变量----系统变量-----新建----classpath(变量名)------
.(点）+;(分号)+jdk里面的lib目录+;(分号)+jdk里面的lib命令+tools.jar+确定（变量值）
检验jdk配置完成 ：Dos窗口，java –version(中间有空格) 显示版本号说明配置成功。 Version(版本)
Jdk如何卸载：开始菜单-----控制面板----程序-----程序和功能
----卸载update(是对java的升级补丁)和development.
环境变量：（environment variables）一般是指在操作系统中用来指定操作系统运行环境的一些参数，如：临时文件夹位置和系统文件夹位置等。
环境变量中的%PATH%代表的是可执行文件的搜索路径，默认为Windows目录（C:windows)和系统目录（C:windowssystem32）,在此两个目录中的文件或文件夹不需要输入完整路径即可通过运行打开。我们还可以把其他路径加加入到%Path%变量，这样你就可以通过运行开输入你要打开的程序。
为了方便我们以后执行java的相关程序命令，我们就要把存放的java命令的jdk下目录bin目录和jre下bin目录都添加到环境变量的path变量中。
另外：一个其它相关程序运行中，会调用JAVA_HOME的环境变量，所以我们为了以后用到这些相关程序不出错误，我们要配置JAVA_HOME:配置的值就是jdk的安装目录。
1.3 计算机基础知识资料下载网址：刘沛霞 18600949004
code.tarena.com.cn
tarenacode
code_2017
笔记下载：先下载，再用world方式打开，这时候复制到新创建的文档图片就可以显示了。
qq如果是对方手机登录，发送不了文件夹。只能都是电脑登录，可以把文件压缩发送。（选中文件夹右键----如：添加到“晨讲.rar”）
计算机（Computer）全称：电子计算机，俗称电脑。是一种能够按照程序运行，自动、高速处理数据的现代化智能电子设备。由硬件和软件所组成，没有安装任何软件的计算机称为裸机。常见的形式有台式计算机、笔记本计算机。按照规模分为微型机、小型机、大型机、巨型机（超级计算机）等。
计算机的应用已渗透到社会的各个领域，正在改变着人们的工作、学习和生活的方式，推动着社会的发展。哪些方面?
计算机硬件（Computer Hardware）是指计算机系统中由电子，机械和光电元件等组成的各种物理装置的总称。这些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
计算机通常由CPU、主板、内存、电源、主机箱、硬盘、显卡、键盘、鼠标，显示器等多个部件组成。
一、电脑的硬件系统
所谓硬件，就是用手能摸得到的实物，一台电脑一般有：
1、主机：主机从外观看是一个整体，但打开机箱后，会发现它的内部是由很多独立的部件组成。
下面介绍一下电脑主机的各个部件：
（1）电源：电源是电脑中不可缺少的供电设备，它的作用是将220V交流转换为电脑中使用的5V，12V，3.3V直流电，其性能的好坏，直接影响到其他设备的稳定性。
（2） 主板：主板是电脑中各个部件的工作平台，它把电脑的各个部件紧密连接在一起，各个部件通过主板进行数据传输。
（3） CPU:CPU的功能是执行算，逻辑运算，数据处理，四舍五入，输入/输出的控制电脑自动，协调地完成各种操作。
（4） 内存：内存又叫内部存储器，属于电子式存储设备，它由电路板和芯片组成，特点是体积小，速度快，有电可存，无电清空，在电脑开机状态时可存储数据，关机后将自动清空其中的所有数据。
（5） 硬盘：硬盘属于外部存储器，由金属磁片制成，磁片有记忆功能，所以储到磁片上的数据，不论在开机，还是关机，都不会丢失。
（6） 声卡：声卡是组成多媒体电脑必不可少的一个硬件设备，它的作用是当发出播放命令后，声卡将电脑中的声音数字信号转换成模拟信号到音箱上发出声音。
（7）显卡：显卡在工作时与显示器配合输出图形，文字，它的作用是负责将CPU送来的信号转换成显示器识别的模拟信号，传送到显示器上显示出来。
（8） 调制解调器：调制解调器是通过电话线上网时必不可少的设备之一。它的作用是将电脑处理的数字信号转换成电话线的模拟信号。
（9） 网卡：网卡的作用是充当电脑与网线之间的桥梁，它是用来建立上网的重要设备。
（10） 软驱：软驱用来读取软盘中的数据。软盘为可读写外部存储设备。
（11） 光驱：光驱是用来读取光盘中的数据。光盘为只读外部存储设备.
2、显示器：显示器有大有小，有薄有厚，其作用是把电脑处理的结果显示出来。它是一个输出设备。
3、键盘：键盘是输入设备，用来把文字，数字等输入到电脑。
4、鼠标：当人们移到鼠标时，电脑屏幕上就会有一个箭头指针跟着移动，并可以很准确移动到指定位置，快速地在屏幕上显示。
5、音箱：通过它可以把电脑中的声音播放出来。
6打印机：通过它可以把电脑中的文件打印到纸上，它是重要的输出设备之一。
7、摄像头、扫描仪、数码像机等设备、
计算机软件（Computer Software）是使用计算机过程中必不可少的东西，计算机软件可以使计算机按照事先预定好的顺序完成特定的功能，计算机软件按照其功能划分为系统软件与应用软件
系统软件： DOS(Disk Operating System), Windows, Linux, Unix, Mac, Android, iOS
应用软件：office QQ 英雄联盟 王者荣耀
这种操作系统是目前世界最多和用途最广泛的操作系统，由微软公司开发。目前已有Windows 98 /2000/7/8/10等众多版本，目前用户数量最多的是WIN7操作系统，最经典的是WINDOWS XP操作系统。Win10是最新最安全的操作系统，但是因为谦容问题没有太多的人所接受。
Linux系统
Linux是一种自由和开放源码的类Unix操作系统，存在着许多不同的Linux版本，但它们都使用了Linux内核。这种系统多用于企业，方便管理服务器等硬件。
1.3.4 软件开发软件
按照特定顺序组织的计算机数据和指令的集合
开发
软件的制作过程
软件开发
借助开发工具与计算机语言制作软件
语言
人类进行沟通交流的各种表达符号，方便人与人之间进行沟通与信息交换
计算机语言
人与计算机之间进行信息交流沟通的一种特殊语言
计算机语言中也有字符，符号等等
常见的计算机语言如C,C++,C#,JAVA
软件的出现实现了人与计算机之间更好的交互。
交互方式
图形化界面：这种方式简单直观，使用者易于接受，容易上手操作。
命令行方式：需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些命令。
Tab
Shift Ctrl Alt
空格 Enter
Window
上下左右
PrtSc(PrintScreen)屏幕截图 （按键+ctrl+v到 word文档，全屏）
Ctrl+A 全选
Ctrl+C 复制
Ctrl+V 粘贴
Ctrl+X 剪切
Ctrl+Z 撤销
Ctrl+Y 反撤销
Ctrl+S 保存…
多选： ctrl+鼠标
1.3.8 常用的DOS命令DOS命令，计算机术语，是指DOS操作系统的命令，是一种面向磁盘的操作命令，主要包括目录操作类命令、磁盘操作类命令、文件操作类命令和其它命令。
目前大家常用的操作系统有windows10,windows 7等，都是图形化的界面。在有这些系统之前的人们使用的操作系统是DOS系统。
(现在用的是图形化界面，以前电脑用的是dos命令来输入指令的。在java开发中我们会用到dos命令窗口，如linux的服务端系统用到)
打开DOS控制台的方式 （Window+R,cmd 进入DOS窗口（ctrl键和alt键之间的就是window键） 在窗口上右键属性，可以更改颜色，字体大小等。）
计算机----属性----查看计算机的基本信息。
注释：输入后+enter键。每个命令输入后都需要enter键
注意： 在DOS窗口复制路径黏贴ctrl+v在windows7不能用。Windows10可以.所以只能用鼠标右键黏贴
常用DOS命令
cmd 进入DOS窗口
默认是在c盘下，可以切换盘符。
e: 进入e盘
dir 列出当前目录下的目录和文件（包括隐藏目录）
mkdir 新建文件夹
rmdir 删除文件夹
cd java 进入java目录（中间有空格）
cd … 退到上层目录
cd / 退到根目录
exit : 退出dos命令行#######
cls : (clear screen)清屏#######
Ipcongfig 查看本机的ip地址（相当于电脑的身份证，一个电脑只有一个）
可以用键盘上下键切换输入过得命令，不许要在重新输入命令。一个电脑可以同时打开多个dos窗口，但键盘上下只能用于同一个窗口命令。
Jdk里面目录的介绍：1，bin目录里面几乎都是exe文件，exe文件在windows操作系统中意味着可执行文件。即可以直接使用的Dos命令。总结：bin目录是二进制文件，存放的都是一系列jdk与java有关的命令。
db:数据库，不怎么用。
Include:jdk与windows系统底层交互的一些东西。
Jre:jdk包含的运行环境。所一说外面的那个jre可以不需要安装。
Lib:类库文件，存放的是jdk已经写好的文件代码，我们可以直接调用。
2个解压包是：jdk开源的源代码。
其它的是版权等文件。
配置环境时一般用到的是bin,jre,lib目录。
Eclipse（IBM公司，开源的、免费的、不需要安装仅需解压即可
） 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言,它只是一个框架和一组服务,用于通过插件组件构建开发环境。
Java开发工具：
文本编译器（一般不用）： 记事本 EditPlus Notepad++…
集成开发环境工具: Eclipse/STS(安装了Spring插件的Eclipse)
IDEA NetBeans…(企业开发一般使用这一类的工具)
1、官网下载并安装
2、下载完整的打包文件（java ee企业版），直接解压就可以用
用来保存所有的开发文件和代码等，也可以切换工作空间，将来你自己的代码就去这个位置找就可以了。
类名要符合驼峰命名法。
快捷键：
输出快捷键， syso +alt+/
Main,方法快捷键, main+alt+/
删除工程，选中工程，右键—delete ----ok(打钩是全部删除，包括worksplse空间里的)
包名全小写。
class HelloWorld{
public static void main(String [] args){
System.out.println(“Hello World”);//不加双引号输出的是它所代表的内容。加双引号直接输出引号里的内容。
}
} //鼠标放到大括号上会自动显示对应的大括号
1.5.5 说明
//单行注释
package cn.tedu.hello;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("hello java");
}
}
1.5.6 运行与工作原理
1、编译：通过javac命令将java的源文件也就是.java文件编译成.class文件。
2、执行(运行期)：
先启动java虚拟机，不同的操作系统有不同的jvm，因此java跨平台。
再通过JVM加载HelloWorld.class字节码文件。并加载main方法执行程序。
同时安装两个版本，jdk1.7和jdk1.8
指定使用jdk1.8版本（就是配置哪个版本的环境变量）
java源文件扩展名是.java。
java编译后的文件扩展名是.class。
左下角开始菜单—计算机-----工具-----文件夹选项-----查看-------隐藏已知文件类型的扩展名。
自己下载并使用
1.6.2 JDK JRE JVM的关系1、JDK–Java Development Kit是针对Java开发员的产品，是整个Java的核心，包括了Java运行环境JRE、Java工具和Java基础类库。
2、JRE–Java Runtime Environment是运行JAVA的运行时环境，包含JVM和Java核心类库。
3、JVM–Java Virtual Machine，Java虚拟机的缩写，是整个java实现跨平台的最核心的部分，能够运行以Java语言写作的软件程序。
Java程序会被编译成字节码组成的class文件，这些字节码可以运行在任何平台，因此Java是平台独立的。
2 Day02–数据类型+运算符 2.1 前言 2.1.1 标识符可以简单的理解为一个名字。在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等。我们选择的名称就称为标识符，并且遵循以下规则：
A.标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符。
B.不能以数字开头。
C.标识符是严格区分大小写的。
D.标识符的命名最好能反映出其作用，做到英文的见名知意。
在java语言中已经被赋予特定意义的一些单词。一共有53个关键字。其中有两个保留字:const（常数，不变的）和goto（转到）。关键字不能被用作标识符！！ （保留字，暂时没用未来也许会用）
Java中关键字很多，不需要强制记忆，因为在编译程序是如果你使用了关键字做标识符编译器会提醒你出错。
Java代码的解释说明。不影响程序的运行，用于辅助读程序。
//单行注释 8888888888（ctrl+/）
( 只能 /**+enter)
查看源码， ctrl+鼠标点击。
syso+alt+/: 输出语句快捷键
ctrl +/ : 选中多行代码，快速添加单行注释。（取消掉，再次快捷键）
Ctrl+shift+o: 导包快捷键
Ctrl +d: 每次删除一行的快捷键（在要删除的代码块，后使用快捷键可以删除一行）
ctrl +n 快捷键相当于new在用上下键 （创建项目，包，类全程不用鼠标）
Alt+上下箭头（对代码进行上下移动）
转义字符：用来表示特殊的符号或特殊意义.
b :表示后退一个字符
t :表示一个制表位
n :表示换到下一行
r:回车
” :表示双引号
’ :表示单引号
:表示反斜杠字符
System,out.println(); //换行
System,out.println(“ ”);//输出一个空格
System,out.println(“t”); //对齐：输出的数加上空格一共8位。也可以改为
（“ “）的形式。
解释： 房间 --------- 变量
房间名字--------- 变量名
房间类型-------- 变量类型
入住的客人------- 变量值
在JAVA中，有的数据值是不固定的，总在变，我们还需要记录这些值，我们可以把这些值理解为变量。
变量的本质：其实是内存里的一部分空间，创建变量的时候，意味着向操作系统申请一部分内存的空间，声明不同类型的变量本质上就是申请的内存空间大小不一样；（程序的执行的第一步，都是载入内存.技术安吉程序的执行和硬件的关系）
我们通过三个元素来描述变量：变量类型，变量名以及变量值。
int age=18; //声明int类型的变量并赋值 String tel; //声明String类型的变量
= 赋值号，右边的数据，赋予给左边的变量。
注意：java中的标点符号是英文的。譬如语句结束的分号，是英文符号的分号，千万不能写成中文。
注意：
1、变量名必须是一个有效的标识符。
2、变量名不可以使用java关键字
3、变量名不能重复
Java中变量使用的规则：
1.java中的变量需要先声明后使用
2.变量使用时，可以声明变量的同时进行初始化（初始化及第一次赋值），也可以先声明后赋值
3.变量中每次只能附一个值，但可以修改多次。
4.Main方法中定义的变量必须先赋值，然后才能输出
5.虽然语法中没有提示错误，但实际开发中，变量名不建议使用中文，容易产生安全隐患，譬如后期跨平台操作时出现乱码等等。
6.变量的使用必须与数据类型匹配。
7.变量作用域范围：从变量的声明开始一直到包含它最近的大括号的程序结束
8.变量命名规则：驼峰命名法"score,myScore,myJavaScore（第二个单词首字母大写）
在程序运行过程中一致不会改变的量成为常量。
略。。。
从小到大：byte short int long float double
char
位bit 字节byte 1byte=8bit
java语言是一种强类型语言。通俗点说是，在java中储存的数据都是有类型的，且在编译时就确定其类型。
基本数据类型：变量存的是数据本身。（相当于抽屉里的东西）
引用数据类型：（除了基本类型都是）变量存的是保存数据的空间地址。（相当于抽屉的钥匙）
一个字节8位。
2.2.2 练习1：最大值最小值package day0102;
//总结
//1，基本类型：byte short int long float double char boolean
//2，工具类：Byte Short Integer Long Float Double Character Boolean
//3,工具类提供了很多功能，其中就包含了大小值
888888888888888888888888888，应该是属性
//基本类型对应的包装类提供了一些功能，最大值，最小值 没有括号不是方法
注意包装类首字母大写，尤其2个特殊
public class Test1 {
public static void main(String[] args){
//=====1、整型测试开始
//变量类型 变量名 = 变量值
byte a=-128; 打印变量的值，不需要" "
byte b=127;
short c=Short.MIN_VALUE;
short d=Short.MAX_VALUE;
int e=Integer.MIN_VALUE;
int f=Integer.MAX_VALUE;
long g=Long.MIN_VALUE;
long h=Long.MAX_VALUE;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
System.out.println(f);
System.out.println(g);
System.out.println(h);
//=====整型测试结束
//=====浮点测试开始
float i=Float.MIN_VALUE; //1.4E-45（代表10的负45次方）
float j=Float.MAX_VALUE; //3.4028235E38(代表10的38次方)
double k=Double.MIN_VALUE; //4.9E-324
double l=Double.MAX_VALUE; //1.7976931348623157E308
System.out.println(i);
System.out.println(j);
System.out.println(k);
System.out.println(l);
//=====浮点测试结束
//float是单精度，对小数运算不精确。double是双精度，对小数运算精确。 对于编程人员来说，double和float的区别是double精度高，但double消耗内存是float的两倍。且double的运算速度较float稍慢。
//=====字符测试开始
//！！！字符char 单引号
字符串String （S大写） 双引号
char c = 'a';//可以存一个字母或者数字或者符号不能没有，可以是空格
char c4='1'; //数字也只能存一个。
char c2 = 97;//可以直接存数字（可以写多个数字）
char c3 = '中';//可以存一个中文汉字
System.out.println(c);
//char类型可以存一个数字，但是在使用时，并不是使用了数字本身，而是去查数字对应的字符，然后使用字符。888888888888888
//ascii码表，规定了数字和字符的对应关系。其中数字97就是对应了字符a。 9 7----a 65---A 48---0
//ascii码表里，规定了0~127数字对应的字符，char类型的取值
//范围是0~65535.那么从128~65535默认对应的字符是?.
System.out.println(c2);//a
System.out.println(c3);
//布尔
boolean b = true;
boolean b2 = false;
}
}
//System.currentTimeMillis()用于获取自1970.1.1零时到此时此刻的毫秒数
2.2.3 练习2：输入个人信息
王海涛今年20岁，月薪20000，奉劝大家拼命学java，才能早日走向人生巅峰。
package day0201_规则;
import java.util.Scanner;
public class Test1_个人信息 {
public static void main(String[] args) {
System.out.println("姓名：");
String name= new Scanner(System.in).nextLine();
//注意：String对应的是Line
System.out.println("性別：");
String gender= new Scanner(System.in).nextLine();
System.out.println("年龄：");
//其它的都是首字母大写
int age= new Scanner(System.in).nextInt();
System.out.println("您输入的个人信息是：");
System.out.println("姓名："+name);
System.out.println("性別："+gender);
System.out.println("年龄："+age);
}
}
练习字符串的拼接过程。
大家好，我叫渣渣辉，今年28。
package cn.tedu.basic;
//这个类用来测试字符串拼接
public class Test2_Info {
public static void main(String[] args) {
//值是一串，Java里表示一串数据，就是String类型。
String name = "蔡徐坤";
byte age = 28;
//通过+拼接字符串， "+?+"
System.out.println("大家好，我叫"+name+"，今年"+age+"。");
}
}
2.2.4 练习3：圆形面积
圆的面积：πrr
圆的周长：2πr
package day0104;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
//定义变量，记录半径r
// double r = 10.1;//不好，值写死了。
//动态的接受键盘输入的值88888888888888888
//测试时：console试图中小红点常亮，表示等待用户的输入，输入完毕后敲回车，表示输入结束。
double r = new Scanner(System.in).nextDouble();
double result = 3.14*r*r;//带入公式
System.out.println(result);
//或者 System.out.println(3.14*r*r);
}
}
2.2.5 练习4：变量交换
接收用户输入的值：假设a=1,b=2将a和b的值做交换。
package day0103;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
/ /1，接受键盘输入整数a和整数b
System.out.print("输入整数a:");
int a=new Scanner(System.in).nextInt();
//前后对照
System.out.print("输入整数b:");
int b=new Scanner(System.in).nextInt();
//2.开始交换
int t=a; //把a的值给t 首尾相连
a=b; //把b的值给a
b=t; //把t的值给b
System.out.println(a);
System.out.println(b);
}
//第二种方式：a=a+b; b=a-b;a=a-b 另一种2个数进行交换
}
2.2.6 引用类型
引用类型是一个对象类型，值是什么呢？它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。如：类，接口，数组,后面讲。。。
2.3 基本类型的字面值（5条） 2.3.1 整数字面值(默认值)是int类型int a = 9999999999;//错，右侧是int类型，但是超出范围2.3.2 byte，short，char三种比int小的整数可以用范围内的值直接赋值
byte b=127;//对 byte b=128;//错，右面已经超过byte范围是int类型的数据 超过范围的相加 加2次最大值等于它本身（所有的基本类型）2.3.3 浮点数的字面值是double类型
double a=3.14;//对 float a=3.14;//错，右面是double，float是四字节double是八字节存不下2.3.4 字面值后缀l f d
//因为它默认的是int类型虽然可以自动转，但是它超出本身的范围了。所以加上一个L 表示long 类型。 //这个整数默认是int类型，但是超出了int范围，还想使用怎么办？ //加后缀L，用来把字面值是int类型的数据，提升成long类型 L –long 如：long a = 99999999999;//错，超出范围，解决方案加L //后缀f，用来把默认的double类型的小数，转成float类型 F –float 如：float a = 3.14;//错，右面是double类型，解决方案加F //后缀d，用来把字面值是int类型的3，转成double类型 D –double 如：double a=3;//错，右面是int，解决方案加D或者改成3.0 //后缀一般默认是大写，因为小写有时候想数字1不好区分。 注意不加也不报错，因为3在double类型的取值范围之内。2.3.5 进制前缀
0x - 16进制 0 -8进制 u -char类型，16进制 0b -2进制 0b00112.4 基本类型的类型转换 2.4.1 小到大（隐式转换）
Byte a =120; Int b=a;//直接转 （整形可以转换为浮点型） char可以直接转化为int类型2.4.2 大到小（显式转换）
需要强制类型转换
int xx = 356; byte y=(byte) xx;
注意：小数转成整数，小数直接舍弃
double y = 9.1; int x = (int)y;//右侧的y是大类型，给小类型x赋值时，需要强转、 System.out.println(x);//9，丢弃小数部分 不管0.1还是0.9全都舍弃2.5 运算规则（5条） 2.5.1 计算结果的数据类型，与最大类型一致
3/2 得1 ，而不是1.5，结果是int类型 3d/2 得1.5，相当于double/int，结果是double类型2.5.2 byte,short,char三种比int小的整数，运算时会先自动转换成int
byte a=3; byte b=4; byte c=a+b;//错，运行时，byte会先自动转成int再运算，int+int还是int byte c = (byte)(a+b); //右侧的a+b运算时，会自动变成int类型，是大类型。给左面的c小类型赋值？？--不能直接赋值需要强转2.5.3 整数运算溢出
整数运算，类似于一个钟表，转到最大时，再转会回到最小。
计算：光速运行一年的长度是多少米
System.out.println(300000000*60*60*24*365); System.out.println(300000000l*60*60*24*365); //运算结果，字面值就是int类型。但是，已经超出了int取值范围，就会整数运算溢出现象 //解决方案：把int字面值加L后缀扩大，变成long类型、 一般是第一个数后2.5.4 浮点数运算不精确
java提供了解决方案，后面就会讲到。
System.out.println(1-0.8); System.out.println(4.35*100);2.5.5 浮点数的特殊值
Infinity 无穷大 3.14/0 Nan not a number 0/0.0 //输出结果不能出现这种情况，一旦出现检查代码（分母为0或分子分母都为0）2.6 拓展 2.6.1 什么是显示类型转换和隐式类型转换
略
2.6.2 char 型变量中能不能存储一个中文汉字，为什么？char 类型可以存储一个中文汉字，因为 Java 中使用的编码是 Unicode（不选择任何特定的编码，直接使用字符在字符集中的编号，这是统一的唯一方法），一个 char 类型占 2 个字节（16 比特），所以放一个中文是没问题的。
3 Day03–方法+流程控制+循环 3.1 运算符 3.1.1 概述注意：逻辑运算符:&&,||,! (且 或 非)是(运算结果是boolean型true或false)建立在关系运算符之上
一般在程序中想要表示true或者false可以，用1表示true，用0表示false
单与：& -- 表示并且的关系
1 & 2 -- 1和2都为true，结果为true
单或：| -- 表示或者的关系
1 | 2 -- 1和2有一个为true，结果为true
88888888888888888888888888888888
双与/短路与：&& -- 表示并且的关系，高效
1 && 2 -- 2会被短路，前提是1为false
双或/短路或：|| -- 表示或者的关系，高效
1 || 2 -- 2会被短路，，前提是1为true
真 & 真 -》真
真 & 假 -》假
假 & 真 -》假
假 & 假 -》假
假 | 假 -》假
假 | 真 -》真
真 | 假 -》真
真 | 真 -》真
练习1：平年闰年
输入年号，判断是否是闰年。两个条件：
1、能被4整除，并且不能被100整除
2、或者能被400整除
package day0203_平年闰年;
import java.util.Scanner;
public class Test1 {
public static void main(String[] args) {
System.out.println("年号：");
int y = new Scanner(System.in).nextInt(); //1，接受用户输入的年号
String r="平年"; //默认都是平年
//2，判断，这个年号到底是平年还是闰年
if(y%4==0){
if(y%100!=0){
r="闰年";
}
}
if(y%400==0){
r="闰年";
}
或者
//说明：
//两个大条件之间是或者的关系，为了高效，用双或
//大条件1有两个小条件，两个小条件之间是并且的关系，为了高效，用双与
//能否被整除，要取余数，余数为0就是能整除。余数不是0就是不能整除。
if( ( year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
//如果年号，能满足判断条件，会进来修改r的默认值为闰年。如果没满足，就一直是默认值平年
r = "闰年";//修改r的值为闰年
if((y%4==0&&y%100!=0)||y%400==0){
r="闰年";
}
System.out.println(y+"年是"+r);
}
}
3.1.2 练习2：自增自减
创建day03工程
创建cn.tedu.basic包
创建Test1_Zizeng.java
package cn.tedu.basic;
//这个类用来测试自增自减
public class Test1_Zizeng {
public static void main(String[] args) {
int a = 1;
//符号在后，先使用后变化
System.out.println(a++);//1
int b = 1;
//符号在前，先变化后使用
System.out.println(++b);//2
//运输按顺序：b=1,先变化++b=2,在使用把2赋值给b=2.注意这里变化之后的是++b=2
System.out.println(++a+b+a++);//3+2+3
88888888888888888888888888888
//注意最后一个3是前面++a的3，而不是上面的3
int c = 1;
System.out.println(c--);//1
int d = 1;
System.out.println(--d);//0
System.out.println(--c-d-d--);//-1-0-0
}
}
3.1.3 练习3：求两个数里的大值
package cn.tedu.basic;
import java.util.Scanner;
//这个类用来测试两个数里的大值
public class Test3_Max {
public static void main(String[] args) {
//1，接受键盘输入的两个整数
8888888888888888888888888
//注意：scanner可以直接写，然后三目运算符boolean是他的返回值
前面可以写其他的类型来接受
int a = new Scanner(System.in).nextInt();
int b = new Scanner(System.in).nextInt();
//2，比大小 1 ？ 2 ：3 ，1判断完如果成立，得到的结果就是2
//a > b成立的话，把a交给max记录，否则，把b交给max记录
int max = a > b ? a : b ;
System.out.println(max);
}
}
3.1.4 练习4：求三个数的最大值
package day0203_平年闰年;
import java.util.Scanner;
public class Test1_三个数的最大值 {
public static void main(String[] args) {
System.out.println("整数a:");
int a = new Scanner(System.in).nextInt();
System.out.println("整数b:");
int b = new Scanner(System.in).nextInt();
System.out.println("整数c:");
int c = new Scanner(System.in).nextInt();
int max = a>b?a:b;
max=max>c?max:c; //分开写
或者
int max = a>b?(a>c?a:c):(b>c?b:c); //合一块写
System.out.println(max);
}
}
3.2 分支结构1：if
3.2.1 概述
顺序结构的程序虽然能解决计算、输出等问题，但不能做判断再选择。对于要先做判断再选择的问题就要使用分支结构。
总结：
任何复杂的程序逻辑都可以通过三种结构来实现:
1)顺序结构:从上往下逐行执行，每句必走
2)分支结构:有条件的执行某语句 一次，并非每句必走
3)循环结构:有条件的执行某语句多次，并非每句必走
单分支：
if(判断条件){
代码。。。
}
多分支：
if(判断条件){
代码1。。。
}else{
代码2。。。
}
嵌套分支：
if(判断条件1){
代码1。。。
}else if(条件2){
代码2。。。
} else if(判断条件3){
代码3。。。
}else{
代码4。。。
}
对于条件结构中，如果省略了大括号，则只会对第一句代码生效（及：如果没有大括号到第一个分号结束）
//换句话说：如果条件结构中只有一句代码，则大括号可以省略
//最后一步是 else 还是else if要分具体情况
接收用户输入的原价。满1000打9折。满2000打8折。满5000打5折。
package day999;
import java.util.Scanner;
public class ttt {
public static void main(String[] args) {
System.out.println("输入总原价");
//1，接受用户输入的原价
double price = new Scanner(System.in).nextDouble();
//2,计算折后价，并输出
double now = price;//记录折后价
//注意java中的条件不能写成如：a>b>c 而是要用逻辑运算符a>b&&b>c来输出。
if( price >= 5000 ) {//满5000
now = price * 0.5 ;//now记录5折的价
}else if( price >= 2000 ) {//满2000
now = price * 0.8 ;//now记录8折的价
}else if( price >= 1000 ) {//满1000
now = price * 0.9 ;//now记录9折的价
}
或者
if( price >= 1000 && price < 2000) {//满5000
now = price * 0.9 ;//now记录9折的价
}else if( price >= 2000 && price < 5000 ) {//满2000
now = price * 0.8 ;//now记录8折的价
}else if( price >= 5000 ) {//满1000
now = price * 0.5 ;//now记录5折的价
}
System.out.println("原价是："+price+"，折后价是："+now);
}
}
3.2.4 练习2：统计学员得分
90分以上 优秀
80~89 良好
70~79 中等
60~69 及格
60分以下 不及格
package game;
import java.util.Scanner;
public class aa {
public static void main(String[] args) {
double score = new Scanner(System.in).nextDouble();
//!!!用来增强代码的健壮性
if (score >= 100 || score <= 0) {
System.out.println("请输入0~100以内的值");
return; //结束程序
}
if (score > 90 && score <= 100) {
System.out.println("优秀");
} else if (score >= 80 && score <= 90) {
System.out.println("良好");
} else if (score >= 70 && score <= 79) {
System.out.println("中等");
} else if (score >= 60 && score <= 69) {
System.out.println("及格");
}else if (score < 60) {
System.out.println("不及格");
}
}
}
//优化
String desc = "优秀";
if(score >= 90) {//90分以上 优秀
desc = "优秀";
}else if(score >= 80 && score < 90 ) {//80~89 良好
desc = "良好";
}else if(score >= 70 && score < 80 ) {//70~79 中等
desc = "中等";
}else if(score >= 60 && score < 70 ) {//60~69 及格
desc = "及格";
}else if(score < 60) {//60分以下 不及格
desc = "不及格";
}
System.out.println("得分是："+score+",属于："+desc);
3.3 [了解]分支结构2：switch
3.3.1 概述
当一个case成立，从这个匹配到的case向后穿透所有case，包括default，直到程序结束或者遇到break程序才结束。
优点:效率高、结构清晰
缺点:(只适用于 )整数、相等
switch(expr1)中,expr1是一个整数表达式， 整数表达式可以是int基本类型或Integer包装类型,由于byte,short,char都可以隐含转换为int，所以也支持。
注意： jdk1.7以后新增 String
switch(变量或者表达式){
case 1:
case 2: break; //break: 跳出switch循环
case 3:
case 4:
default: default 加个保险也可以不写,当前面都没有匹配到的时候相当于加个保险走默认的。
}
3.3.3 练习1：数字匹配
package cn.tedu.ifdemo;
//测试switch语法
public class Test7_Switch {
public static void main(String[] args) {
int i = 2;
//3, i 的类型 也就是括号里表示的类型 -- byte short int char jdk1.7新增了String
switch( i ) {
case 1 : System.out.println(1);break;
case '1' : System.out.println('1');break;
//1, 当匹配到case时，程序会继续向后穿透所有case包括default
case 2 : System.out.println(2);break;
//2, break用来结束程序
case 3 : System.out.println(3);break;
case 4 : System.out.println(4);break;
case 5 : System.out.println(5);break;
case 6 : System.out.println(6);break;
default: System.out.println(0);//default之后不需要再写break
}
}
}
//如果输出的条件一样则可以简写为如：
case 0:
case 1:
case 2:
case 3:
System.out.println("小明");
break;
3.4 循环结构1：for
3.4.1 概述
循环结构是指在程序中需要反复执行某个功能而设置的一种程序结构。
它由循环体中的条件，判断继续执行某个功能还是退出循环。
根据判断条件,循环结构又可细分为先判断后执行的循环结构和先执行后判断的循环结构。
.循环三要素:
1)循环变量的初始化
2)循环的条件(以循环变量为基础)
3)循环变量的改变(向着循环的结束变)
循环变量:在整个循环过程中所反复改变的那个数
for(开始条件；循环条件；更改条件){
循环体代码…
}
For循环的特殊用法：
1. For(; ;){ //死循环
}
2. int i=1;
for(;i<10;i++){
}
for(int i=1;i<10;){
i++; //注意这个地方多了个分号（;）
}
3. 可以同时声明2个数：
for(int i=1,j=6;i<6;i+2,j--){
} //for中表达式一和表达式三可以使用逗号，而表达式二多个只能使用 && || ！(且或非)
3.4.3 练习1：打印0到10
package cn.tedu.fordemo;
//测试for循环
public class Test8_For {
public static void main(String[] args) {
//for( 开始条件 ; 判断条件 ; 更改条件 ){ 循环体 }
// 打印0到10
//i用来记录每次获取到的值，默认是从0开始
for( int i = 0 ; i <= 10 ; i++){
System.out.println(i);
}
}
}
3.4.4 练习2：打印10到0
//从10开始，只要>=0，就打印，打印的数据依次递减
for( int i = 10 ; i >= 0 ; i-- ){
System.out.println(i);
}
练习3：打印8,88,888,8888
for( int i = 8 ; i <= 8888 ; i=i*10+8 ){
System.out.print(i+",");//同行展示数据。如8,88,....
}
3.5 拓展
3.5.1 &和&&的区别
当一个&表达式在求值的时候，两个操作数都会被求值，&&更像 是一个操作符的快捷方式。当一个&&表达式求值的时候，先计算第一个操作数，如果它返回true才会计算第二个操作数。如果第一个操作数 取值为fale,第二个操作数就不会被求值
3.5.2 a=a+4和a+=4的区别byte a = 1; // a=(byte) (a+4);//右侧int，左侧byte，大转小，强转。 // a=(byte) (a+4);//右侧int，左侧byte，大转小，强转。 a+=4;//会自动完成数据类型的转换 888888888888888888 //注意：a=a+4和a+=4是有区别的！！ System.out.println(a);3.5.3 求【1,100】中，奇数的个数，偶数的个数
int count = 0;//定义变量，记录奇数的个数888888888888888888888
int oucount = 0;//定义变量，记录偶数的个数,(定义为0，下面赋值不会影响程序)
for(int i = 1 ; i <= 100 ; i++) {
//判断，如果是奇数
if( i % 2 == 1 ) { //也可以写！=0
count++;//每次遇到一个奇数就+1
}
//判断，如果是偶数
if( i % 2 == 0 ) {
oucount++;//每次遇到一个偶数就+1
}
}
System.out.println("奇数的个数是："+count+",偶数的个数是："+oucount);
3.5.4 求【1,100】中，偶数的和奇数和
int sum = 0;//定义变量，记录偶数和
int jisum = 0;//定义变量，记录奇数和
for(int i = 1 ; i <= 100 ; i++) {
//判断，如果是偶数
if(i % 2 == 0) {
//对获取到的每个偶数求和
sum = sum + i;
}
//判断，如果是奇数
if(i % 2 == 1) { //或则i%2!=0也行
jisum = jisum + i;//把每个奇数求和
}
}
System.out.println("偶数和是："+sum+",奇数和是："+jisum);
4 Day04–循环+变量
4.1 嵌套for循环
4.1.1 概述
根据外层的条件，判断里层能否执行，如果能执行，就把里层代码都循环完毕后，再继续执行外层，继续判断。。
4.1.2 形式for(…){
for(…){
}
}
4.1.3 入门案例
package day0000;
public class T {
public static void main(String[] args) {
// f1();
f2();
}
//总结1：当i=1时，j取到了所有满足条件的数据，1,2,3,4,5。
//也就是说外循环执行1次，内循环执行多次
private static void f1() {
for(int i=1;i<=3;i++){//外循环
System.out.println("i="+i);//1,2,3
for(int j=1;j<=5;j++){//内循环
System.out.println("j="+j);//1,2,3,4,5
}
}
}
//总结2：外循环控制行，内循环控制列
private static void f2() {
for(int i=1;i<=3;i++){
for(int j=1;j<=5;j++){
System.out.print("*");
}
System.out.println();
}
}
}
4.1.4 练习1：打印正方形
//正方形
for(int i=1;i<5;i++){
for(int j=1;j<5;j++){
System.out.print("*");
}
System.out.println();
}
4.1.5 练习2：打印左直角三角形
*
**
***
****
*****
//正直角三角形
private static void f4() {
for (int i = 0; i < 5; i++) {//外循环，控制行，是一定的
for (int j = 0; j <= i; j++) {//内循环，列是不固定的，是递增的
System.out.print("*");//保证第一行打印出来一个*，注意条件
}
System.out.println();
}
}
4.1.6 练习3：打印99乘法表
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
//99乘法表 正序
private static void f4() {
for (int i = 1; i < 9; i++) {//外循环，控制行，是一定的
for (int j = 1; j <= i; j++) {//内循环，列是不固定的，是递增的
System.out.print(i+"*"+j+"="+i*j+" ");//保证第一行打印出来一个*，注意条件
}
System.out.println();
}
}
//乘法表倒序
for(int i=9;i>=1;i--) {
for(int j=1;j<=i;j++) {
System.out.print(j+"*"+i+"="+i*j+"t");
}
System.out.println();
}
4.2 break和continue
用来终止循环，可以用两种方式
4.2.1 形式break: 中断当前循环，简单粗暴
for(){
代码1
if(条件){
代码3…
break;//如果成立，直接跳出这个for循环
}
代码2…
}
continue：跳出本次循环，进入下一轮
for(){
代码1
if(条件){
代码3…
continue;//如果成立，跳出本次for循环，进入下一轮
}
代码2…
}
4.2.2 练习1：找数字88
接收用户输入的100次数字，如果不是88继续输入，找到88就返回
package cn.tedu.breakdemo;
import java.util.Scanner;
//测试break和continue
//总结：break和continue都可以结束循环。
//1，break可以立刻结束循环简单粗暴。continue是结束当前循环可以继续下一次循环。
88888888888888888888888888
//2，break和continue之后都不能出现代码，出现了也是不可到达的代码
public class Test3_Break {
public static void main(String[] args) {
for(int i = 1 ; i <= 100 ; i++) {
//1，接受用户输入的数字
int input = new Scanner(System.in).nextInt();
//2，判断是不是88
if(input == 88) {//是88
System.out.println("中了");
break;//程序结束
}else if(input != 88) {//不是88
continue;//继续输入
}
}
}
}
4.3 循环结构2：while
先判断，再执行
4.3.1 格式while(执行条件){
代码…
}
4.3.2 练习1：猜数字
产生一个随机数，和用户一直在输入的数字比较。
package cn.tedu.whiledemo;
import java.util.Random;
import java.util.Scanner;
//测试while循环
//总结
//while也是一种循环结构：while(循环条件){循环体}
//while(true)是简单的实现了死循环的形式，for也可以实现代码显得复杂一些。
//这种结构 -- 先判断，再执行
public class Test4_While {
public static void main(String[] args) {
//1,让程序产生随机数 --nextInt(m) 要产生m以内的随机数，默认从0开始 ，不包括m 如：0~100 不包括100(0~99)可以加个1变为（1~100）
//产生随机数的方法：实例化一个Random方法在调用nextInt方法
// 第2种; int num=(int)(Math.random()*1000+1);//生成随机数1～1000
// 注意2者之间的大小写,括号，它是小数转化为int类型需要强转
注意：这个方法不传参是int范围(-21亿多~21亿多)，传参才是规定的范围。
int random = new Random().nextInt(100) +1;
//第1种： 如，nextInt(3) （0 1 2）
nextInt(3)+1 （ 1 2 3）//注意它是从0开始不包括
它本身3，然后变化可一给他加个数。
System.out.println(random);
//2,开始猜 --重复做a b的事情，放入循环结构中
// while(random > 50) {
//for形式的死循环:让循环条件一直为true就行
// for(int i = 1; i >= 1 ; i++ ) {
while(true) { //死循环 -- 必须设置程序的出口！！
8888888888888888888888
//a,接受键盘输入的值
int input = new Scanner(System.in).nextInt();
//b,拿到输入的值，和 ，random去比
if(input > random) {
System.out.println("大了");
}else if(input < random) {
System.out.println("小了");
}else if(input == random) {
System.out.println("中了");
break;//程序结束 -- 死循环的出口！！！
}
}
}
}
4.4 循环结构3：do-while
先执行，再判断
4.4.1 格式do{
代码…
}while(执行条件); //注意这里有个分号
4.4.2 练习1：猜数字
产生一个随机数，和用户一直在输入的数字比较。
package cn.tedu.whiledemo;
import java.util.Random;
import java.util.Scanner;
//测试do...while循环
//总结：
//do...while 结构，保证循环体代码 ，最少，执行一次
//能不能继续循环，要看能不能满足循环条件
public class Test5_Dowhile {
public static void main(String[] args) {
int random = new Random().nextInt(100) + 1;
System.out.println(random);
do {
// a,接受键盘输入的值
int input = new Scanner(System.in).nextInt();
// b,拿到输入的值，和 ，random去比
if (input > random) {
System.out.println("大了");
} else if (input < random) {
System.out.println("小了");
} else if (input == random) {
System.out.println("中了");
break;// 程序结束 -- 死循环的出口！！！
}
}while (random > 50);//明确循环条件
}
}
4.5 变量
4.5.1 概念
可以改变的数，称为变量。一般通过三部分来描述一个变量。变量类型，变量名，变量值。其中三部分都是可以改变的，根据需要来确定即可。
变量的使用原则：就近原则。尽量控制到最小范围。。
定义在方法里，或者局部代码块中。（方法里）
注意：必须手动初始化（赋初值），来分配内存。如：int i=5;
作用域也就是方法里或者局部代码块里，方法运行完内存就释放了。
定义在类里。（类里方法外）
注意：不用初始化，也会自动被初始化成默认值。
作用域是整个类中，类消失了，变量才释放。
char： /u0000 (默认值，一般不显示)
空白符的code是0x20,0x20以下是不可兼得控制字符。某些系统在遇到不可见字符时会输出一个方框表示遇到了不可见字符。
引用类型(除了8大基本类型)：默认值为 null
| 基本类型 | 默认值 |
|---|---|
| byte | 0 |
| shot | 0 |
| int | 0 |
| long | 0L |
| float | 0.0f |
| double | 0.0d |
| boolean | false |
package cn.tedu.variable;
import org.junit.Test;
//测试 变量的使用
public class Test6_Variable {
//TODO 测试其他类型 的默认值
//2,成员变量:位置是在类里方法外 + 有默认值 + 作用范围是整个类里
double count ;
//3,就近原则---前提是---当成员变量 和 局部变量同名时,你使用的一定是局部变量
int sum = 20 ;
//单元测试junit :要求方法要有标志@Test + 方法必须是public的 + 方法返回值是void，没有参数列表
@Test //需要导包（1 2 都可以）
public void show() {
//1,局部变量:位置是在方法里 + 必须初始化 + 作用范围是方法里
int sum = 10;
System.out.println(sum);//10,就近原则
System.out.println(count);//0.0
}
}
package cn.tedu.arrays;
public class Test2_Variable {
//1、成员变量：在类里方法外是
//作用范围就是整个类里
//可以不初始化，也会有默认值
int age = 20;
int sum = 30;
public static void main(String[] args) {
//2局部变量：在方法里是
//作用范围就是方法里，出了这个方法就不认识了
//必须初始化
int sum = 10;
System.out.println(sum);//10
//3、变量的就近原则，附近有同名的会去执行最近的
System.out.println(sum);//10
}
}
4.6 拓展：
4.6.1 三种循环的区别
三种循环都可以互相代替
1、for：知道循环次数（应用率最高）
2、while/do while：当循环次数不确定时
3、while：先判断，不符合规则，不执行代码（有可能一次都不执行）
4、do while：代码最少被执行一次，再去判断，符合规则，再次执行代码
5、如何判断是用哪个循环？
1.如果与次数有关则用for循环
2.在判断条件1和条件3是否相同：如果相同则用do while 不同则用while （变量初始化，条件， 改变量）
打印右直角
*
**
***
****
*****
package day999;
public class a {
public static void main(String[] args) {
//输出5行
for(int i=1;i<=5;i++){
//空格三角
for(int x=5;x>i;x--){//还可以改为：for(int x=1;j<=5-i;x++)
System.out.print(" ");
}
//*号三角
for(int j=1;j<=i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
4.6.3 打印全三角形
打印全三角
*
***
*****
*******
*********
package day999;
public class a {
public static void main(String[] args) {
//打印5行
for(int i=1;i<=5;i++){
//打印空格的倒三角(原理是：每轮输出一个空格)
for(int j=5;j>=i;j--){ //可换：for(int j=1;j<=5-i;j++)
System.out.print(" ");
}
//打印*号的正三角
for(int k=1;k<=i*2-1;k++){
System.out.print("*");
}
System.out.println();
}
}
}
5 Day05–方法+数组
5.1 方法
5.1.1 概述：方法（函数，过程）
1．方法：封装一段特定的业务逻辑功能。
2．方法尽可能的独立，一个方法只干一件事。
3．方法可以被反复多次调用用
4．减少代码的重复，有利于代码的维护，有利于团队的协作。
5．方法可以有参，也可以无参，多个参数用逗号隔开（看需求）
6．方法与方法是同级并列关系
修饰符 返回值 方法名(【参数列表】){
方法体;
//返回值， void(无返回值) int,double,String…
}
5.1.3 练习1：方法调用
//根据方法的签名来调用
方法的签名：方法名+参数列表
注意：在一个类中，不可以有2个方法的签名完全相同，及一个类中不可以有2个方法的方法名和参数列表完全相同，但是可以重载（方法名称相同，参数列表不同，方法体不同。因为方法体相同没啥意义。）
语法：
1)无返回值类型: 方法名(有参传参); 实参 在里面赋值值操作(可以是确定的数 也可以是不确定的数) //在调用方法的时候给参数赋值。
2)有返回值类型: 数据类型 变量 = 方法名(有参传参); 只要有返回值，就需要声明一个数据类型来接收
在方法调用时，会将实际的参数值传递给方法的参数变量。必须保证传递参数的类型和个数符合方法的声明。
package cn.tedu.method;
888888888888888888//包名可以直接在代码上修改，鼠标放上去会提示创建没有的包。
//同理 ：类也一样
//测试方法的使用+-------------------------------
public class Test6_Method {
public static void main(String[] args) {
System.out.println(1);
function();//调用了指定的function()
System.out.println(2);
}
//创建function() 如果没有在main方法中调用方法，则程序不会主动执行这个方法。
//修饰符 返回值 方法名(参数列表){方法体}
public static void function() {
System.out.println(3);
System.out.println(4);
System.out.println(5);
}
}
5.1.4 练习2：方法传参
package cn.tedu.method;
//测试方法的使用
public class Test6_Method {
public static void main(String[] args) {
System.out.println(1);
// function();//调用了指定的function()
// param(10);//方法传参
// param2("jack",10);//传两参数--叫实参
//注意：调用方法时传的参数叫做实参，不管是数字还是一个变量都是实参
888888888888888888888888
// param3(5,10,"jack"); 参数的个数和类型相同，但是顺序不同也代表
参数列表不同，方法不同。
param4("jack",5,10);
System.out.println(2);
//在括号外面赋值，方法与直接赋值一样。
int m=10;
String n=”rose”;
Param5(m,n);
}
//创建param5的方法
public static void param5(inta,String b) {
System.out.println(a+b+);
}
//TODO 创建param4("jack",5,10) --方法传参：参数类型必须匹配
public static void param4(String a,int b,int c) {
System.out.println(a+b+c);//jack510
}
//TODO 创建param3(5,10,"jack") --方法传参：参数类型必须匹配
//多个参数之间用”,”隔开。
public static void param3(int a,int b,String c) {
//+在数字间是加法运算，和字符串+是拼接字符串
System.out.println(a+b+c);//15jack
}
//创建param2("jack",10) --方法传参：参数类型必须匹配
//String n,int a -- 叫形参：方法里面的参数叫形参
public static void param2(String n,int a) {
System.out.println(n);
System.out.println(a);
}
//创建param() --方法传参：参数类型必须匹配
//修饰符 返回值 方法名(参数列表){方法体}
// public static void param(参数类型 参数名) {
public static void param(int num) {
System.out.println(num);
}
//创建function()
//修饰符 返回值 方法名(参数列表){方法体}
public static void function() {
System.out.println(3);
System.out.println(4);
System.out.println(5);
}
}
5.1.5 练习3：方法返回值
package cn.tedu.method;
//方法可以有返回值，也可以没有返回值（void）
//何时有返回值？何时无返回值？
当方法执行结束时：
1.若还需要用到方法中的某一个数据----有返回值（有返回值就需要定义一个变量或数组来接受它。和return连用）
2. 若不在需要用到方法中的某一个数据----没有返回值
return:方法结束后可以返回一个数据，称之为返回值，方法在声明时必须指定返回值的类型。
Return用法？
（1）return 值 ；
1.结束方法的执行
2.返回给调用方。（注意只要有返回值类型一定有return 数值）
（2） return ;
1. 结束方法的执行（无返回值类型不需要写return，因为程序执行完照样结束，直接写没有意义。有时可以和if分支结构连用用于跳出程序。）
//测试方法返回值
public class Test7_Method2 {
public static void main(String[] args) {
//result记录着method()的执行结果a b的和
int result = method(10,5);
System.out.println(result);
//TODO
String name = method2("jack","rose","jerry");
System.out.println(name);
}
//TODO 创建 method2("jack","rose","jerry")
public static String method2(String a,String b,String c){
return a+b+c;//返回值不单单是一个变量，数。也可以返回一个式子
}
//创建method(10,5)
//注意：方法的返回值要和result变量的类型一致
public static int method(int a,int b) {
//通过 return 可以把方法执行的结果，返回给，调用位置！！
return a+b;
}
}
//注意：例子，返回的是不同类型看是否是字符串拼接，用String
String sum2=method("jack",10,5);
System.out.println(sum2);
public static String method(String c,int a,int b) {
return c+a+b; //这里是一个字符串的拼接所以用String类型。返回值类型与return后的类型一致。
}888888888888888888888888
5.2 方法的重载Overload
5.2.1 概念
1.方法重载是指在一个类中，方法名相同，参数列表不同（是里面的参数类型不同，不是它的名字不同），方法体不同，相同没啥意义。
2.编译器在编译期间会根据方法的签名自动绑定调用不同的方法。（我们可以把重载的方法可以看成是完全不同的方法，只不过恰恰好方法名相同而已。
但要求每个方法具有不同的参数列表(也就是说参数的个数和类型不同)。
注意：如果参数列表相同，但是顺序不同那么参数列表也算不同。
//重载的意义：对于程序员而言，需要记忆的方法名很简单只需要记住一个名字的方法，方法的参数可以很灵活的传入。
。
程序调用方法时，可以通过传递给它们的不同个数和类型的参数来决定具体使用哪个方法。
//重载也可已发生在父子类中88888888888888
package cn.tedu.overload;
//测试方法重载：
//要求：方法名相同+参数列表不同
//意义：由于用户在使用时，传入的参数我们不知道，为了体现我的程序非常的灵活
//尽量多提供一些参数不同，名字相同的方法
public class Test8_Overload {
public static void main(String[] args) {
add(5);
add(10,5);
add("jack",5);
add(10,"rose");
//TODO
print(10);
print("jerry");
print('中');
}
//创建add(10,"rose")
public static void add(int a,String b) {
System.out.println(a+b);//10rose
}
//创建add("jack",5)
public static void add(String a,int b) {
System.out.println(a+b);//jack5
}
//创建add(10,5)
public static void add(int a,int b) {
System.out.println(a+b);
}
//创建add(5)
public static void add(int a) {
System.out.println(a*a);
}
}
//总结：方法，传参，数据类型与参数列表保持一致，（即：个数，类型，顺序
保持一致。
返回值：若有返回值应与返回值类型，返回值接受的类型保持一致。
如：
public static void main(String[] args) {
//方法练习
method(2,3,"小明");
String aa=method2(2,3,"小红");
System.out.println(aa);
}
public static void method(int a,int b,String c) {
System.out.println(a+b+c);
}
public static String method2(int a,int b,String c) {
return a+b+c;//有String类型，int 类型。它拼接的是字符串类型，所以应该用
String作为它的返回值类型，它的接受值也是String类型。
}
5.2.3 练习2：数据的打印
package day004;
public class Test07 {
public static void main(String[] args) {
// TODO Auto-generated method stub
print(10);
print(2.2);
print(true);
print("jack");
}
public static void print(int a) {
System.out.println(a);
}
public static void print(double a) {
System.out.println(a);
}
public static void print(boolean a) {
System.out.println(a);
}
public static void print(String name) {
System.out.println(name);
}
}
5.3 数组
5.3.1 概念
数组Array。标志[ ]。
是用于储存多个相同类型数据的集合。
想要获取数组中的元素值，可以通过元素的下标来获取，下标是从0开始的。
//数组 Array是引用类型，储存的是地址，地址在空间中占得内存很少（就是一串数字） 下标的最大值是它的长度-1；
一般分为动态初始化和静态初始化
数组–à应用类型（除了8大基本类型之外都是引用类型）
语法： 数组类型 数组名 =数组对象；（中括号和数组名位置可以互换）
输出是[]
动态初始化：先声明后赋值
int[] a = new int[10];//数组的类型应该与所存入的每一个数据类型一致
//数组之间的元素用逗号隔开。
静态初始化:声明数组的同时赋值
int[] b = new int[]{1,2,3,4,5};
int[] c = {1,2,3,4,5};
5.3.3 练习1：数组中存入hello
package cn.tedu.array;
import java.util.Scanner;
//这个类用来测试数组的创建
public class Test1_Array {
public static void main(String[] args) {
//1，创建数组。存入hello
//确定数组类型，数组长度
// 静态
//因为每个格子放一个字符，所以用char类型。
char[] a = new char[] {'h','e','l','l','o'};
char[] b = {'h','e','l','l','o'};
System.out.println(a);
System.out.println(b);
// 1，动态 创建数组，需要，指定数组的长度！！
char[] c = new char[5];
//注意：存字符串是用的char 数组。不是string
//2，数组中的元素都有下标，默认从0开始
c[0]='h';//给第1个元素，也就是下标为0的元素，赋值
c[1]='e';//给第2个元素，也就是下标为1的元素，赋值
c[2]='l';//给第3个元素，也就是下标为2的元素，赋值
c[3]='l';//给第4个元素，也就是下标为3的元素，赋值
c[4]='o';//给第5个元素，也就是下标为4的元素，赋值
888888888888888888
//3，java.lang.ArrayIndexOutOfBoundsException数组下标越界异常
//原因是数组的长度如果是5，最大下标是4，根本不存在下标为5的情况，下标5超出范围
//c[5]='o';//给第6个元素，也就是下标为5的元素，赋值 --- 报错！！
System.out.println(c);
}
}
5.3.4 数组的长度
length属性获取数组长度（数组有length属性，没有length方法）
数组一旦创建，长度不可变 //数组是定长的
允许0长度的数组
从头到尾，依次访问数组的位置。
5.4.1 形式for(从下标为0的位置开始；到数组长度-1结束；下标++){
循环体
}
5.4.2 练习1：输出每个月的天数
package cn.tedu.array;
//数组练习
public class Test2_Array2 {
public static void main(String[] args) {
method();// 输出每个月的天数
}
// 创建method()
public static void method() {
// 1，静态创建数组
int[] days = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
// 2，用下标遍历数组
// i代表了下标
// int i = 0 ，从下标0开始
// i <= days.length-1，到下标的最大值结束
// i++，依次向后遍历
for (int i = 0; i <= days.length - 1; i++) {
// days[i] 指days数组中，每个下标存着的值
System.out.println((i + 1) + "月有" + days[i] + "天");
}
}
}//直接输出数组则输出的是地址，输出对应的下表才是他代表的元素
5.4.3 练习2：遍历数组，存入1到10
// 创建method2()
public static void method2() {
//1，动态 创建数组
int[] a = new int[10];
// [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
System.out.println(Arrays.toString(a));
//2，遍历数组，存数据
for(int i = 0 ; i <= a.length-1 ; i++ ) {
//获取每个元素a[i]
a[i] = i+1;
}
888888888888888888888888888888
//3,查看数组中的元素 [I@659e0bfd
System.out.println(a);
//除了char数组可以直接输出里面的元素，其它的数组都是地址
//想看不是char[]的数组里的元素是啥--
//Arrays工具类 toString()可以将指定的数组数据显示成一个字符串
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
System.out.println(Arrays.toString(a));
}
5.4.4 练习3：创建随机数组
获取100以内的随机值的数组
// 创建method3()
public static void method3() {
//1， 动态 创建数组
int a[] = new int[10];
//2. 遍历数组，重新赋值
for(int i = 0 ; i <= a.length-1 ; i++) {
//a[i]获取元素
a[i]=new Random().nextInt(100);
}
//3. 查看数组里的元素
System.out.println(Arrays.toString(a));
}
5.5 数组工具类Arrays
5.5.1 Arrays.toString(数组)
把数组里的数据，用逗号连接成一个字符串。（返回值是String）
格式：[10, 14, 20, 46, 51]
package day006;
import java.util.Arrays;
public class Test02 {
public static void main(String[] args) {
// to String
method();
}
public static void method() {
int[] aa= {1,2,3,4,5,6};
// for(int i=0;i
// }
System.out.println(Arrays.toString(aa));
} //直接打印是地址值如： [I@15db9742
使用工具类后是：[1, 2, 3, 4, 5, 6]
}
5.5.2 Arrays.sort(数组)
对数组排序，对于基本类型的数组使用优化后的快速排序算法，效率高。
对引用类型数组，使用优化后的合并排序算法。
例子： //注意它的输出方式
int []as= {4,9,4,1,2,5,9,6,4,5,2};
Arrays.sort(as);8888888888888
System.out.println(Arrays.toString(as));
把数组复制成一个指定长度的新数组。（改变的只是新数组，原数组没有发生变化）
新数组长度大于原数组，相当于复制，并增加位置。–数组的扩容
新数组长度小于原数组，相当于截取前一部分数据。–数组的缩容
package cn.tedu.array;
import java.util.Arrays;
//测试数组工具类
//为什么sort()没有返回值是，void
//为什么copyOf()有返回值，如：int[]
//原因是：sort()在原数组基础上，把数组调整位置
//copyOf():数组一旦创建，长度不可变！！！所以必须把产生的新数组返回/而这里改变了长度。888888888888888
public class Test4_Arrays {
public static void main(String[] args) {
int[] a = {97, 7, 41, 37, 55, 3, 3, 34, 34, 83};
// sortArray(a);//a是实参，给无序数组排序
int[] newA = copyArray(a);//数组复制a是原数组
// [97, 7, 41, 37, 55, 3, 3, 34, 34, 83, 0, 0, 0, 0, 0]
// [97, 7, 41, 37, 55]
System.out.println(Arrays.toString(newA));
}
//创建copyArray第一种方式，可以扩容，缩容（及新数组的长度大于小于新数组的畅读都可以）
public static int[] copyArray(int[] from) {
//copyOf(from，num)--from是原数组名，num是新数组长度 -- 新数组长度 > 原数组长度 -- 扩容
int[] to = Arrays.copyOf(from, 15);
// [97, 7, 41, 37, 55, 3, 3, 34, 34, 83, 0, 0, 0, 0, 0]
//from是原数组名，5是新数组长度 -- 新数组长度 < 原数组长度 -- 缩容 --相当于截取数据。
int[] to2 = Arrays.copyOf(from, 5);
// [97, 7, 41, 37, 55]
return to2;
}
//创建sortArray
public static void sortArray(int[] a) {//形参
//sort()用来对无序数组进行排序
Arrays.sort(a);//底层源码
// [3, 3, 7, 34, 34, 37, 41, 55, 83, 97]
//toString()对指定的数组内容，显示成字符串
System.out.println(Arrays.toString(a));
}
}
例子：
//数组的复制 第2种 都是在新的数组上改变，注意两者写法的区别。
int [] we= {4,8,5,8,9}; //新数组小了自动截取，大了会自动填充。
int[] we1=Arrays.copyOf(we, 4);
System.out.println(Arrays.toString(we));
System.out.println(Arrays.toString(we1));
System.out.println("11111111111");//打桩
int[] we2=new int[5];//这个是新数组长度小则会有数组小标越界异常。那个不会。优点是显得更灵活。
System.arraycopy(we,0,we2,0,5);
System.out.println(Arrays.toString(we2));
//数组的扩容
int we3[]=Arrays.copyOf(we, we.length+1);
System.out.println(Arrays.toString(we3));
5.6 拓展：
5.6.1 了解二维数组
存放数组的数组，也就是说数组里存的还是数组的数据形式。
public class Test06 {
//ctrl +n 快捷键相当于new在用上下键 （创建项目，包，类全程不用鼠标）
public static void main(String[] args) {
// 二维数组: 数组套数组
//格式： 定位：如，c[0][1] 遍历2次.
int [][] c={{1,2},{3,4},{5,6}};//声明形式
for(int i=0;i<=c.length-1;i++) {//遍历外层数组
for(int j=0;j<=c[i].length-1;j++) { //遍历内层数组
System.out.println(c[i][j]);//输出形式
}
}
5.6.2 了解冒泡排序
冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
package cn.tedu.bubble;
//第一种 20个数比 20轮 每轮比-i-1次
//第二种 20个数比19轮 每轮比-i次
import java.util.Arrays;
//这个类用来测试冒泡排序算法
public class Test3_Bubble {
public static void main(String[] args) {
//1，定义无序数组
int[] a = {21, 94, 21, 58, 47, 16, 10, 9, 50, 44};
//2，排序
//5个数，比4轮。外循环控制轮数，让外循环执行4次
//i < a.length-1 a.length是5，-1 就是 4，i<4，外循环执行4次
for(int i = 0 ; i < a.length-1 ; i++ ) {
//内循环控制每轮需要相邻比较多少次
//-i ：第1轮，需要比4次，五个数参与比较 -0，
//第2轮，需要比3次，四个数参与比较 -1，(因为第一轮沉出来一个大值不参与比较)
//第3轮，需要比2次，四个数参与比较 -2，(因为前两轮沉出来两个大值不参与比较)
//第4轮，需要比1次，四个数参与比较 -3，(因为前三轮沉出来三个大值不参与比较)
for(int j = 0 ; j < a.length-1 - i; j++ ) {
//1，相邻元素比较
//前一个值a[j]大于后面的值a[j+1]
if(a[j]>a[j+1]) {
//2,交换顺序s
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
System.out.println(Arrays.toString(a));
}
}
5.6.4 了解其他算法
如：合并算法，二分算法，快速算法等，冒泡最常见，也是面试中出现率最高的
