我的第一个Java程序
Public static void main(arr[] args){
System.out.print(“hello world”);
}
JVM虚拟机相当于计算机系统（操作系统+硬件环境）
jre = java虚拟机 + 核心类库(辅助java虚拟机运行的文件)
jdk = jre + java开发工具
简述环境变量path和classpath的作用？搭建环境变量path 可以在任意目录下运行对应目录的所有软件
独立编写hello world程序，编译并运行。class Demo{ public static void main(String[]args){
System.out.println(“hello world”);
}
}
java语言是否区分大小写? class的作用,javac,java的作用？分、class 存放代码 javac 编译代码 Java 执行代码
简述main方法(是什么，什么特点，怎么用，何时用？)Main 主方法，一个类有且仅有一个主方法，一个类必须要用一个主方法，程序的入口
计算机 = 硬件 ＋ 软件
硬件：
cpu : cpu是计算机中的运算核心与控制核心。负责了解析计算机的指令、与计算机运算的执行。
内存: 数据与cpu交互的桥梁。 程序所需要的数据都会先加载到内存中，cpu是直接读取内存中数据运算的。
特点： 存取速度快。 缺点：断电或者是程序退出的时候，内存中的数据都会丢失。
硬盘（机械硬盘、固态硬盘）：可以永久性保存数据， 缺点： 存取的速度慢。 固态硬盘： 读取速度非常快。
软件：软件就是按照一定顺序组织起来的计算机指令与数据的集合。 软件 = 数据 + 指令
软件的类别：
系统软件：
比如： windows 、 linux 、 mac os 、 ios 、 android（改UI）
应用软件: 应用软件必须要在系统软件的基础上才能使用的。
比如： QQ、 微信、 迅雷、 飞信...。。。
软件的本质（软件为我们解决了什么问题）： 提高了人类与计算机的交互效率。
人类与计算机的交互方式：
1. 图形化界面的交互方式： 简单 、 功能强大。
2.通过dos命令的交互方式： 特点： 需要记忆大量的dos命令， 功能比较弱小。
首先具备一个控制台(命令行提示符窗口)用于输入dos命令：
打开一个控制台的方式：
方式一：开始-------> 所有程序--------->附件----------->命令提示符
方式二：开始------->运行-------->输入cmd即可.
常见的dos命令：
盘符： 进入指定的盘下面。
操作文件夹:
dir 列出当前控制台所在的路径下的所有文件以及文件夹。
cd 路径 进入指定的路径下。
cd .. 回退到上一级目录上。
cd \ 回退到当前路径下的根目录。
md 文件夹的名字 创建一个文件夹
rd 文件夹的名字 删除一个空文件夹。 注意： 不能用于删除非空到的文件夹。
操作文件：
echo 数据>文件名 创建一个文件并且指定写入的数据。
type 文件名 查看指定的文件内容。
del 文件名 删除指定的文件。 注意： del后面如果跟一个文件夹，那么是删除一个文件夹中的所有文件。
* 通配符（可以匹配任意的文件名）
tab 内容补全.
cls 清屏
上下方向键 找回上一次所写过的命令。
exit 关闭控制台。
计算机语言(更好的与计算机进行交互):
计算机的发展历史：
机器语言：010101010101010
汇编语言 通过大量的英文单词代表计算机的指令。 add 1 1
高级计算机语言: C \ JAVA \ C++ \ PHP
1993 , JAVA初衷： 机 1994 年互联网刚刚兴起,.（高司令\ 高斯林），改造成了面向互联网的计算机语言。
java重要特性之 ------- 跨平台(一次编译，到处运行).
平台： 操作系统。
java的环境的搭建：
jre: java运行环境。 jre = java虚拟机 + 核心类库(辅助java虚拟机运行的文件)
jdk： java开发工具集 jdk = jre + java开发工具。
安装jdk的路径要注意： 不能带有中文路径或者是空格。
jdk目录的介绍：
bin: 存放的是java的开发工具。
db : JDK7附带的一个轻量级的数据库，名字叫做Derby。
include ：存放的调用系统资源的接口文件。
jre ： java运行环境
lib : 核心类库。
src.zip : java源代码
java.exe 启动java虚拟机解释并执行指定的class文件。
java工具的使用格式：
java 指定的class文件
javac.exe 启动java编译器对指定的java源文件进行编译、。
编写第一个java的程序：
第一步： 新建一个txt文件。把后缀名改成java。
第二步： java 代码全部都是写到类上面的。
如何编写一个类：
使用一个关键字class即可定义个类。
格式：
class 类名{
} 备注： 大括号表示是一个类的范围，在类的范围之内都可以写代码，
第三 步： 编写一个主方法。 主方法的写法是固定的，是一个程序的入口，代码从主方法开始执行，
如何启动java编译对java的源文件进行编译？
javac的使用格式：
javac java源文件。
编译的过程中我们就面临 的问题：每次编译 的时候都需要写上java源文件的完整路径。 烦！！！
解决方案： 如果可以在任意的路径下都可以找到java的开发工具，那么该问题就解决了。
在控制台写一个可执行文件的文件名的执行原理：
在控制台写一个可执行文件的文件名,那么系统首先会在控制台当前路径下去搜索是否存在该文件，如果可以找到指定的文件，
那么就执行该文件，如果找不到该文件，那么系统还会根据path的环境变量所保存的路径信息下去搜索是否有指定的文件，如果
能找到，那么就执行该文件。
配置path环境变量：
如何找到path的环境变量:
我的电脑-------属性------------>高级系统设置---------->高级--------->环境变量------------path
把javac所在的路径拷贝到path环境变量中即可。
标识符: 在java程序中有些名字是可以自定义的，那么这些自定义的名字我们就
称作为自定义的标识符。
标识符要注意的细节：
1. 标识符的组成元素是由 字母（a-zA-Z） 、数字(0-9) 、 下划线(_)、 美元符号($).
2. 标识符不能以数字开头。
3. 标识符是严格区分大小写的。
4. 标识符的长度是没有长度限制的。
5. 标识符的命名一般要有意义（要做到让人见名知意）
6. 关键字、保留字不能用于自定义的标识符。
自定义标识符的规范：
1. 类名和接口名单词的首字母大写，其他单词小写。 比如： RunTime.
2. 变量名与方法名首单词全部小写，其他单词首字母大写，其他小写。 比如： doCook()；
3. 包名全部单词小写。
4. 常量全部单词大写，单词与单词之间使用下划线分隔。 比如： UP_DIRECTION
判断一下那些是 符合的标识符:
12abc_ 不合法 数字不能开头
_12abc 合法
$ab12# 不合法 #号不属于标识符组成元素。
abc@123 不合法 @号不属于标识符组成元素。
关键字：关键字就是在java程序中具备特殊含义的标识符。关键字一般用于描述一个程序的
结构或者表示数据类型。
*/
/*
需求：编写一个java程序模拟QQ登陆.
注释： 注释就是使用文字对程序的说明，注释是写给程序员看的，编译器会忽略注释的 内容的。
注释的类别：
第一种： 单行注释。 // 注释的内容
第二种： 多行注释。 /* 注释的内容 */
/*
第三种： 文档注释. /** 注释的内容 */
/*
文档注释也是一个多行注释。
注释要注意的细节：
1. 单行注释可以嵌套使用，多行注意是不能嵌套使用的。
注释的作用：
1. 使用文字对程序说明。
2. 调试程序。
*/
/*
软件 = 数据+ 指令+ 文档
常量: 常量就是程序在运行过程中其值不能发生改变的量。
常量的类别：
整数常量 10 12
小数常量 3.14
布尔常量 布尔常量只有两个值： true(正确). false(错误)
字符常量 字符常量就是单个字符使用单引号引起来的内容我们称作为字符常量。
字符串产量 字符串常量就是使用双引号引起来的内容称作为字字符串常量。
整数常量的表现形式：整数的表现形式主要是以不同的进制(二进制、八进制、十六进制)表现出来。
进制： 十进制（0~9） 、 星期（七进制 0~6）、 小时(12进制(0-11)、 24进制(0~23))
进制：用有限的数字符号代表所有的数值。
计算机的出现是为了服务于人类的，那么人类在现实生活中使用的数据基本上都是
十进制的数据，那么计算机是否有可以存储现实生活中的数据呢？如果可以存储
又以哪种形式存储呢？
二进制由来。
电脑记录我们现实生活中的数据都是使用二进制进行记录的，那么我们
就要懂得如何把十进制数据转换成二进制。
十进制与二进制之间的转换：
十进制转二进制的方法：使用十进制的数据不断除以2，直到商为0为止。从下往上取余数就是
对应的二进制。
10(十进制)-------->1010(二进制）
二进制转十进制:使用二进制的每一位乘以2的n次方，n从0开始，每次递增1，然后把各部分的数据
相加即可。
1110(二进制) ---------> 14(十进制)
二进制的弊端： 二进制的书写太长了，不方便人类记忆。
二进制的数据特点： 由0~1组成。
解决方案：每三个二进制位就就记录一个数字。
1000（十进制）------> 001,111,101,000（二进制） = 1,7,5,0
一个八进制的数据就是相当于三个二进制位。
十进制与八进制之间的转换：
十进制转八进制:使用十进制的数据不断除以8，直到商为0为止。从下往上取余数就是
对应的八进制。
45(十进制)------> 55 （八进制）
八进制转十进制：使用八进制的每一位乘以8的n次方，n从0开始，每次递增1，然后把各部分的数据
相加即可。
23(八进制)------> (十进制)
八进制数据的特点： 只有0~7这八个字符组成的。
十六进制的数据: 0~9 , a（10）\b (11),c(12),d(13), e(14),f(15)， 四个二进制位就是一个十六进制的数据.
十六进制的数据是有0~9、a-f这几个字符组成的。
十进制转换成十六进制:使用十进制的数据不断除以16，直到商为0为止。从下往上取余数就是
对应的十六进制。
38(十进制)---->26 （十六进制）
十六进制转十进制：使用十六进制的每一位乘以16的n次方，n从0开始，每次递增1，然后把各部分的数据
相加即可。
34(十六进制)-----> 52（十进制）
*/
//二进制 , 如果一个数据要表示二进制，那么要在该数据的前面加上0b开头
//八进制数据， 八进制的数据需要以0开头
//十六进制数据， 十六进制的数据需要以0x开头
如果一个数据没有加上任何的标识之前，默认就是十进制的数据。
/*
声明变量的方式：
声明变量的方式一：
数据类型 变量名;
声明变量的方式二： 一次性声明了多个相同类型变量
数据类型 变量名1 ， 变量2....
注意：
1. 变量是必须先声明再使用。
2. 在一个作用域中不能声明同名 的变量。
*/
/*
软件 = 数据 + 指令 + 文档(使用者文档+ 开发者文档)
文档注释与多行注释的区别：
多行注释与文档注释的区别： 多行注释的内容不能用于生成一个开发者文档，
而文档注释 的内容可以生产一个开发者文档。
使用javadoc开发工具即可生成一个开发者文档。
javadoc工具的使用格式：
javadoc -d 存放文档的路径 java的源文件
使用javadoc工具要注意细节：
1. 如果一个类需要使用javadoc工具生成一个软件的开发者文档，那么该类必须使用public修饰。
2. 文档注释注释的内容一般都是位于类或者方法的上面的。
写注释的规范：一般单行注释是位于代码的右侧，多行注释与文档注释一般是写在类或者方法的上面的。
*/
/*
在现实生活中有很多数据是经常会发生变化 的。
比如： 天气 、 心情 、 时间、 股市...
变量： 变量就是在程序运行过程中其值可以发生变化的量.
变量就是一个存储数据的容器。
容器具备什么特点：
1. 容量(大小)。
2. 存储一定格式的数据。
3. 名字.
声明（定义）一个变量的格式：
容量 变量名字 = 数据。
变量名的命名规范： 首单词小写，其他单词首字母大写，其他小写。
java表示一个变量的容量多大是使用了数据类型描述的。
在java中 的数据类型主要有两种数据类型
基本数据类型
引用数据类型
java中的八种基本数据类型：
整数的数据类型：
byte(字节) 8位（bit） 2^8 = 256 -128~127
short(短整型) 16bit 2^16 = 65536
int(整型) 32bit
long(长整型) 64bit 2^64 =
注意： 如果一个整数没有加上任何的标识的时候，那么默认是int类型的数据。
如果需要把该数据表示成一个long类型的数据，那么需要加数据后面加上L表示，L是不区分大小写的，但是建议使用大写。
疑惑：存储整数可以使用四种数据类型，那么具体怎么选择使用呢？
选用数据类型的原则： 在能满足需求的情况下，能小就小。节省内存空间。
小数的数据类型：
float(单精度浮点型) 32bit
double(双精度浮点型) 64bit
注意： 如果一个小数没有加上任何标识的时候，那么该小数默认是double类型的数据，如果
需要表示成float类型，那么需要在小数的后面加上f表示。f不区分大小写的。
布尔类型： 布尔类型只有两个 值，true或者false。
boolean 1字节或者4个字节
如果使用boolean声明一个基本类型的变量时，那么该变量占4个字节，
如果使用boolean声明一个数组类型 的时候，那么每个数组的元素占
一个字节。
字符类型：
char 2字节（16bit）
八种基本数据类型：
整数：byte short int long
小数： float double
布尔： boolean
字符： char
字符串的数据类型是：String 引用数据类型,不属于基本数据类型。
*/
/*
控制流程语句之（if）判断语句
if判断语句的格式：
格式1：适用于一种情况使用。
if(判断的条件){
符合条件执行的代码;
}
格式2 : 适用于两种情况下去使用的。
if(判断条件){
符合条件执行的代码
}else{
不符合条件执行的代码；
}
三元运算符的格式：布尔表达式？值1：值2;
if-else 与三元运算符非常像：
三元运算符的优点： 结构比较简洁。
三元运算符的缺点： 符合条件必须要返回一个结果，不能执行语句。
格式三： 适用于多种情况下去使用的。
if(判断条件1){
符合条件1执行的代码
}else if(判断条件2){
符合条件2执行的代码
}else if(判断条件3){
符合条件3执行的代码
}......else{
都不符合上述 的条件执行的代码
}
if语句要注意的细节：
1. 如果符合条件后只有一个语句需要执行，那么可以省略大括号。但是建议不要省略，因为结构不清晰。
2. if语句的判断条件后不能添加分号，否则会影响到执行的效果的，
需求1：工作经验要两年或者两年以上。
需求2：根据一个变量所记录的数字输出对应的星期。 0 ---星期天 1 星期一
*/
/*
需求： 键盘录入一个分数，根据分数输出对应的等级。
比如： 100-90 A等级 89-80 B等级 ..... E等级
接受键盘录入数据的步骤：
1. 创建一个扫描器对象。
2. 调用扫描器对象的nextInt方法扫描数据。
3. 导入包。
*/
Import java.util.*;//导入包
Scanner scanner=new Scanner(System.in);
int score=scanner.nectInt();//定义一个变量接收扫描到的内容
/*
java中的八种基本数据类型：
整数：
byte 、 short 、 int 、 long
小数：
float double
字符：
char
布尔：
boolean
字符串的类型： String(引用数据类型)
声明变量的方式：
方式1： 数据类型 变量名 = 数据;
方式2：数据类型 变量名1 ， 变量名2 ......；
*/
/*
数据类型转换：
小数据类型-------->大数据类型 自动类型转换
大数据类型--------->小数据类型 强制类型转换
强制类型转换的格式：
小数据类型 变量名 = (小数据类型)大数据类型
数据类型转换要注意的细节：
1. 凡是byte、short 、 char数据类型数据在运算的时候都会自动转换成int类型的数据再运算。
2. 两个不同数据类型的数据在运算的时候，结果取决于大的数据类型。
*/
/*
算术运算符:
+ (正数、加法、连接符)
连接符的作用： 让任何的数据都可以与字符串进行拼接。
如果+号用于字符串的时候，那么+号就是一个连接符，并不是 做加法功能了。
连接符要注意：任何类型的数据与字符串使用连接符连接，那么结果都是字符串类型的数据。
-
*
/ (除法)
%(取模、取余数)
*/
/*
++ （自增） : 自增就是相当于操作数+1.
前自增：++位于操作数的前面。 比如： ++a；
前自增：先自增，后使用。
后自增： 先使用，后自增。
*/
/*
int a = 0;
//int sum = ++a; //前自增。 a = a+1 ， sum = a
int sum = a++; //后自增 sum = 0 , a = a+1
System.out.println("sum= "+ sum+ " a = "+ a); //1
后自增在jvm的运行原理：
因为后自增要使用 到没有+1之前 的值，那么jvm会先声明一个变量用于保存没有+1之前的值。
int i = 0;
i = temp;
原理：
1. int temp = i; // 声明了一个临时变量用于记录了i没有加1之前的值。
2. 自增。 i = i+1; i = 1;
3. temp把用作了表达式 的结果。
i的值发生了几次变化：
i = 0 -----> 1----> 0
*/
/*
自减： 操作数-1.
前自减: --位于操作数的前面。 --操作数
前自减： 先自减，后使用。
----------------------------------------------
后自减：--位于操作数的后面。 操作数--；
后自减： 先使用，后自减。
*/
/*
赋值运算符：
= (赋值运算符)
+=
-=
*=
/=
%=
*/
/*
逻辑运算符 ：逻辑运算符的作用是用于连接布尔表达式的。
& （与,并且）
规律： 只有左右变量同时 为true，那么结果才是true，否则就为false。
| (或,或者)
规律： 只要两边的布尔表达式有一边为true，那么结果就为true，只有两边同时为false 的时候，结果才是false.
^ (异或)
规律： 只要两边的布尔表达式 结果不一致，那么结果就为true，如果左右两边 的布尔表达式一致，那么就为false.
！ (非)
--------------------
&& (短路与\双与)
短路与和单与符号的相同与不同点：
相同点： 短路与和单与运算 的结果是一样的。
不同点： 使用短路与的时候，如果左边的布尔表达式为false，则不会在运算右边的布尔表达式，从而提高了
效率。使用单与的时候，即使发现左边的布尔表达式为false，还是会运算右边的布尔表达式的。
只有左边的布尔表达式为false时，双与的效率才要高于单与的.
|| (短路或\双或)
短路或与单或的相同点与不同点：
相同点：运算的结果是一致 的。
不同点：使用短路或的时候，当发现左边的布尔表达式为true时，则不会运算右边的布尔表达式。
使用单或的时候 发现左边的布尔表达式为true，还是会运算右边布尔表达式。
需求：要求两年或两年以上的工作经验，年龄大于18岁。
*/
/*
位运算符：位运算符就是直接操作二进制位的。
& (与)
| (或)
^ (异或)
规律： 如果操作数A连续异或同一个操作数两次，那么结果还是操作数A。
应用： 对数据加密.
~ (取反)
*/
/*
比较运算符： 比较运算符的结果都是返回一个布尔值的。
== (判断是否等于)
==用于比较两个基本数据类型数据的时候，比较的是两个变量所存储的值是否一致.
==用于比较两个引用类型变量的数据时候，比较的是两个 引用类型变量所记录的内存地址是否一致.
!= (不等于)
> (大于)
< (小于)
>= (大于等于)
<= (小于等于)
*/
/*
移位运算符：
<<(左移)
规律：一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移 的位数.
3<<1 = 3 *2(1) = 6;
3<<2 = 3*2(2) = 12
3<<3 = 3*2(3) = 24
>>(右移)
规律：一个操作数在做右移运算的时候，实际上就是等于该操作数除以2的n次方，n就是右移的位数。
3>>1 = 3 / 2(1) = 1
3>>2 = 3 / 2(2) = 0 。。
>>>(无符号右移) ：
无符号右移与右移的区别：进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补，
如果操作数是一个负数，那么左边的空缺位使用1补。而使用无符号右移的时候，不管是正数还是负数都
统一使用0补。
笔试题目：使用最高的效率算出2乘以8的结果。
2<<3 = 2*2(3) = 16;
*/
/*
函数（方法）:
函数的作用： 提高功能代码的复用性。
需求：做两个数的加法功能。
目前存在的问题：以下的代码都是在做一个加法功能，而
这里加法功能 的代码目前是没有任何的复用性的。
解决方案： 如果一个功能的代码要被复用起来，那么这时候可以把
这里的功能代码封装起来，在java中把功能代码封装起来的是以函数的形式体现的。
函数的定义格式：
修饰符 返回值类型 函数名(形式参数..){
需要被封装的功能代码；
return 结果;
}
分析函数：
public static int add(){
int a =2;
int b =3;
return a+b;
}
修饰符: public static
返回值类型： int 。 返回值类型就是指函数运行完毕后，返回的结果的数据类型。
注意： 某些函数是没有结果返回给调用者的,那么这时候返回值类型是void。
函数名： add 函数名的作用：如果需要调用该函数就需要使用的函数名。 函数名只要符合标识符的命名规则即可。
函数名的命名规范： 首单词全部小写，其他单词的首字母大写，其他小写。
形式参数： 如果一个函数在运行的时候，存在着数据是要调用者确定 的，那么这时候就应该定义形式参数。
return ： 把一个结果返回给调用者。
函数的特点：
1. 函数定义好之后，是需要被调用才会执行的。 main函数是有jvm调用的，不需要我们手动调用。
*/
/*
需求1： 定义一个函数判断一个分数的等级，把分数的等级返回给调用者。
"A等级" ”B等级“
如何 定义函数：
1. 返回值类型。 String
2. 未知的参数--->形式参数。 分数
需求2： 定义一个函数打印一个乘法表，不需要返回任何数据。
1. 返回值类型。 void
2. 未知的参数--->形式参数。 到底是什么乘法表
函数的特点：
1. 函数的作用就是把一个功能代码给封装起来，已达到提高功能代码的复用性。
2. 函数定义好之后是需要被调用才会执行的。
3. 如果一个函数没有返回值返回给调用者，那么返回值类型必须是使用void表示。
*/ /*
函数的定义格式：
修饰符 返回值类型 函数名(形式参数..){
需要被封装的功能代码；
return 结果;
}
如何定义一个函数：
1. 返回值类型。
2. 是否存在未知的参数(是否存在要由调用者确定的参数)。---->形式参数
*/
/*
控制流程语句之---if 判断语句
格式一： 只适用于一种情况下去使用。
if(判断条件){
符合条件执行的代码;
}
格式二：适用于两种情况下去使用
if(判断条件){
符合条件执行的代码
}else{
不符合条件执行 的 代码
}
]
格式3： 适用于多种情况使用的
if(判断条件1){
符合条件1执行的 语句;
}else if(判断条件2){
符合条件2执行 的语句;
}else if(判断条件3){
符合条件3执行 的语句;
}else if(判断条件4){
符合条件4执行 的语句;
}......else{
都不符合上述 条件执行的代码...
}
*/
/*
控制流程语句之----switch选择判断语句
switch语句的格式：
switch(你的选择){
case 值1：
符合值1执行的代码
break;
case 值2：
符合值 2执行的代码
break;
case 值3：
符合值 3执行的代码
break;
case 值4：
符合值 4执行的代码
break;
......
default:
你的选择都符合上述的选项时执行的代码;
break;
}
switch语句要注意的事项：
1. switch语句使用的变量只能是byte、 char、 short、int、 String数据类型，String数据类型是从jdk7.0的时候开始支持的。
2. case后面跟 的数据必须是一个常量。
3. switch的停止条件：
switch语句一旦匹配上了其中的一个case语句，那么就会执行对应的case中的语句代码，执行完毕之后如果没有
遇到break关键字或者是结束switch语句的大括号，那么switch语句不会再判断，按照代码的顺序从上往下执行
所有的代码。直到遇到break或者是结束siwitch语句的大括号为止。
4. 在switch语句中不管代码的顺序如何，永远都是会先判断case语句，然后没有符合的情况下才会执行default语句。
if--else if---else if 语句与switch语句非常的相似：
switch语句的优点：switch语句的结构清晰。
switch缺点：如果 判断的条件是一个区间范围的，使用switch操作就非常的麻烦了。
判断以下那些不是计算机语言( D )
A java B C# C javascript D android
*/
/*
循环语句----while循环语句
while循环 语句的格式:
while(循环的条件){
循环语句；
}
while循环语句要注意的事项：
1. while循环语句一般是通过一个变量控制其循环的次数。
2. while循环语句的循环体代码如果只有一个语句的时候，那么可以省略大括号。但是也是不建议大家省略。
3. while循环语句的判断条件后面不能跟有分号，否则会影响到执行的效果。
需求： 在控制上打印五句hello world.
*/
//创建随机数对象
Import java.util.*;
Class Games
public static void main(String[] args)
{
Random random=new Random();
Int randomNum=random.nextInt(输入随机数长度);//定义一个变量来接收随机数
Scanner scanner=new Scanner(System.in);
While(true){
Int guessNum=scanner.nextInt();//定义一个变量来接收猜测的数
If(guessNum>randomNum){
System.out.println(“猜大了”);
}else if(guessNum<randomNum){
System.out.println(“猜小了”);
}else{
System.out.println(“猜对了”);
Break;
}
}
/*
控制流程语句----do while循环语句
格式：
do{
}while(判断条件);
需求： 在控制上打印五句hello world.
while循环语句与do-while循环语句的区别：
while循环语句是先判断后执行循环语句的，do-while循环语句
是先执行，后判断。不管条件是否满足至少会执行一次。
*/
/*
控制流程语句之---for循环语句
for循环语句的格式:
for(初始化语句;判断语句;循环后的语句){
循环语句;
}
for循环语句 要注意的事项：
1. for(;;)这种写法 是一个死循环语句，相当于while(true);
2. for循环语句的初始化语句只会执行一次，只是在第一次循环的时候执行而已。
3. for循环语句的循环体语句只有一句的时候，可以省略大括号不写。但是不建议省略。
需求： 在控制上打印五句hello world.
*/
/*
转义字符：特殊字符使用”\”把其转化成字符的本身输出，那么使用”\”的字符称作为转移字符。
需求： 在控制台上打印一个 hello" world
常见的转义字符有：
\b Backspace （退格键）
\t Tab 制表符(制表符的作用就是为了让一列对齐) 一个tab一般等于四个空格。
\n 换行
\r 回车 把光标移动到一行的首位置上。
注意： 如果是在windows系统上操作文件的时候需要换行，是需要\r\n一起使用的。
如果是在其他的操作系统上需要换行，仅需要\n即可。
*/
/*
break、
break适用范围：只能用于switch或者是循环语句中。
break作用：
1. break用于switch语句的作用是结束一个switch语句。
2. break用于循环语句中的作用是结束当前所在的循环语句。
笔试题目：break目前位于内层的for循环，如何才能让break作用于外层 的for循环。
可以标记解决
标记的命名只要符合标识符的命名规则即可。
*/
/*
continue关键字
continue的适用范围： continue只能用于循环语句。
continue的作用：continue的作用是跳过本次的循环体内容。继续下一次。
continue要注意的事项：
1. 在一种情况下，continue后面不能跟有其他语句，因为是永远都无法执行到。
2. continue 也可以配合标记使用的。
*/
/*
函数：
函数的作用： 为了提高功能代码的复用性。
函数的定义格式:
修饰符 返回值类型 变量名(形式参数){
函数体
}
函数的特点：
1. 函数是把一个功能的代码 封装起来以达到提高功能 代码的复用性。
2. 函数定义好之后，需要调用才能执行的。
3. 如果一个函数没有返回值类型，那么就使用void关键字表示。
需求: 定义一个函数判断分数的等级，然后返回分数对应的等级。
"a等级"
*/
/*
注意： 如果一个函数的返回值类型是具体的数据类型，那么该函数就必须要保证在任意情况下都保证有返回值。（除了返回值类型是void以外）
return 关键字的作用：
1. 返回数据给函数的调用者。
2. 函数一旦执行到了return关键字，那么该函数马上结束。 (能结束一个函数)
注意：一个函数的返回值类型 是void，那么也可以出现return关键字，但是return关键字的后面不能有数据。
Continue 关键字 break关键字与return关键字的区别：
1.break关键字是结束一个循环。
2. return关键字是结束一个函数。
3 .continue的作用是跳过本次的循环体内容。继续下一次
*/
/*
需求： 定义一个函数做加法功能。
函数的重载：在一个类中出现两个或者两个以上的同名函数，这个称作为函数的重载。
函数重载的作用： 同一个函数名可以出现了不同的函数，以应对不同个数或者不同数据类型的参数。
函数重载的要求：
1. 函数名一致。
2. 形参列表不一致。（形式参数的个数或者是对应的数据类型不一致）
3. 与函数的返回值类型是无关的。
*/
*
数组：数组是存储同一种数据类型数据的集合容器。
数组的定义格式：
数据类型[] 变量名 = new 数据类型[长度];
分析数组：
左边： int[] arr 声明了一个int类型的的数组变量，变量名为arr。
int : 表示该数组容器只能存储int类型的数据。
[] ： 这是一个数组类型。
arr ： 变量名.
右边：new int[50]; 创建了一个长度为50的int类型数组对象。
new ： 创建数组对象的关键字。
int: 表示该数组对象只能存储int类型数据。
[]： 表示是数组类型。
50 : 该数组最多能存储50个数据。数组的容量。
数组的好处： 对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标）,索引值的范围是从0开始，最大是： 长度-1.
局部变量： 如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。
成员变量： 成员变量就是定义在方法之外，类之内的.
*/
/*
数组中最常见的问题：
1. NullPointerException 空指针异常
原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。\
2. ArrayIndexOutOfBoundsException 索引值越界。
原因：访问了不存在的索引值。
*/
/*
数组的初始化方式：
动态初始化:
数据类型[] 变量名 = new 数据类型[长度];
静态初始化：
数据类型[] 变量名 = {元素1，元素2.....};
如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果
数据一开始还不太明确，这时候就建议使用动态初始化。
*/
/*
数组的特点：
1. 数组只能存储同一种 数据类型的数据。
2. 数组是会给存储到数组中 的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；
3. 数组一旦初始化，长度固定。
4. 数组中的元素与元素之间的内存地址是连续的。
*/
/*
java面向对象的语言
对象：真实存在唯一的事物。
类： 实际就是对某种类型事物的共性属性与行为的抽取。 抽象的概念.... 车
我们从小的时候就不断的接触很多的对象，我们的大脑就会把
这些具备相同属性与行为的事物进行分类。
在现实生活中就存在对象与类这两种事物。计算机是服务于人类，为了让计算机更加接近我们的
生活，这时候就出现了面向对象的计算机语言。
面向过程（C） 面向对象（java）
现实生活中 : 对象---------类
在java中： 类------------>对象
面向对象的计算机语言核心思想： 找适合的对象做适合的事情。
如何找适合的对象：
1. sun已经定义好了很多的类，我们只需要认识这些类，我们就可以通过这些类创建对象使用。
2. 自定义类，通过自定义类来创建对象使用。
自定义类创建对象的三步骤：
1. 自定义类。
格式：
class 类名{
事物的公共属性使用成员变量描述。
事物的公共行为使用函数描述。
}
2. 通过自定义类创建对象。
格式：
类名 变量名 = new 类名();
3. 访问(设置)对象的属性或者调用对象的功能。
1.访问对象属性的格式：
对象.属性名.
2.设置对象的属性：
对象.属性名 = 数据。
3. 调用对象的功能
对象.函数名();
*/
/*
面向对象三大特征：
1. 封装
2. 继承
3 多态。
需求： 使用java类描述百合网的会员。
问题： 性别有问题？？
根本原因： 由于其他人可以直接操作sex属性。可以对sex属性进行了直接的赋值。
封装:
权限修饰符：权限修饰符就是控制变量可见范围的。
public : 公共的。 public修饰的成员变量或者方法任何人都可以直接访问。
private ： 私有的， private修饰的成员变量或者方法只能在本类中进行直接访问。
封装的步骤：
1. 使用private修饰需要被封装的属性。
2. 提供一个公共的方法设置或者获取该私有的成员属性。
命名规范：
set属性名();
get属性名();
疑问： 封装一定要提供get或者set方法吗？
不一定， 根据需求而定的。
规范 ： 在现实开发中一般实体类的所有成员属性（成员变量）都要封装起来。
实体类：实体类就是用于描述一类 事物的就称作为实体类。
工具类(Arrays数组的工具类):
封装的好处：
1. 提高数据的安全性。
2. 操作简单。
3. 隐藏了实现。
*/
/*
成员变量与局部变量的区别:
定义的位置上区别：
1. 成员变量是定义在方法之外，类之内的。
2. 局部变量是定义在方法之内。
作用上的区别：
1. 成员变量的作用是用于描述一类事物的公共 属性的。
2. 局部变量的作用就是提供一个变量给方法内部使用而已。
生命周期区别：
1. 随着对象 的创建而存在，随着对象的消失而消失。
2. 局部变量在调用了对应的方法时执行到了创建该变量的语句时存在，局部变量一旦出了自己的作用域
那么马上从内存中消失。
初始值的区别：
1. 成员变量是有默认的初始值。
数据类型 默认的初始值
int 0
float 0.0f
double 0.0
boolean false
char ' '
String（引用数据类型） null
2. 局部变量是没有默认的初始值的，必须要先初始化才能使用。
*/
/*
匿名对象：没有引用类型变量指向的对象称作为匿名对象。
需求： 使用 java类描述一个学生类。
匿名对象要注意的事项：
1. 我们一般不会给匿名对象赋予属性值，因为永远无法获取到。
2. 两个匿名对象永远都不可能是同一个对象。
匿名对象好处：简化书写。
匿名对象的应用场景：
1. 如果一个对象需要调用一个方法一次的时候，而调用完这个方法之后，该对象就不再使用了，这时候可以使用
匿名对象。
2. 可以作为实参调用一个函数。
*/
/*
对象：真实存在的唯一的事物。
类： 同一种类型的事物公共属性与公共行为的抽取。
java面向对象语言：
核心思想： 找适合的对象做适合的事情.
找对象的方式：
方式一： sun已经定义好了很多了类，我们只需要认识这些类即可创建对象使用。
方式二： 我们需要自定义类，通过自定义类创建对象。
在整理笔记的过程中对自己有疑问的概念使用代码验证或者推翻它。
自定义类三步骤：
1. 自定义一个类。
class 类{
事物 的公共属性使用成员 变量描述
事物的公共行为使用函数描述。
}
2. 可以通过类创建对象。
3. 访问(设置)对象的属性或者调用对象的方法。
成员变量与局部变量 的区别：
1. 自定义的位置区别：
1. 成员变量是定义在方法之外，类之内的变量。
2. 局部变量是声明在方法之内的变量。
2. 作用上的区别：
1. 成员变量的作用描述一类事物的属性。
2. 局部变量的作用是提供一个变量给方法内部使用的。
3. 生命周期的区别；
1. 成员变量随着对象的创建而存在，随着对象的消失而消失。
2. 局部变量是调用到了对应的方法执行 到了创建该变量的语句时存在，一旦出了自己的作用域马上从内存中消失。
4. 初始值的区别：
1. 成员变量是有默认的初始值的。
2. 局部变量是没有默认的初始值的，必须要先初始化才能使用。
匿名对象： 没有引用类型变量指向的对象就称作为匿名对象。
匿名对象要注意的细节：
1. 一般不会给匿名对象的属性赋值，因为永远都没法获取到。
2. 两个匿名对象永远都不可能是同一个对象。
匿名对象好处：简化书写。
匿名对象的应用场景：
1. 如果调用一个对象的方法一次时，然后这个对象就不再使用，那么这时候可以使用匿名对象。
2. 可以作为实参调用一个函数。
封装：
封装的步骤：
1. 使用private修饰需要被封装的属性.
2. 根据需要提供get或者set方法设置以及获取属性。
封装的好处：
1. 提高了数据的安全性。
2. 操作简单。
3. 隐藏了实现。
注意：一般实体类的属性我们都会封装起来。
*/
/*
需求： 使用java类描述一个动物。
问题：存在同名的成员变量与局部变量时，在方法的内部访问的是局部变量(java 采取的是就近原则的机制访问的。)。
this关键字：
this关键字代表了所属函数的调用者对象。
this关键字作用：
1. 如果存在同名成员变量与局部变量时，在方法内部默认是访问局部变量的数据，可以通过this关键字指定访问成员变量的数据。
2. 在一个构造函数中可以调用另外一个构造函数初始化对象。
this关键字调用其他的构造函数要注意的事项：
1. this关键字调用其他的构造函数时，this关键字必须要位于构造函数中 的第一个语句。
2. this关键字在构造函数中不能出现相互调用 的情况，因为是一个死循环。
this关键字要注意事项：
1. 存在同名的成员变量与局部变量时，在方法的内部访问的是局部变量(java 采取的是“就近原则”的机制访问的。)
2. 如果在一个方法中访问了一个变量，该变量只存在成员变量的情况下，那么java编译器会在该变量的 前面添加this关键字。
*/
/*
java是 面向对象的语言： "万物皆对象": 任何事物都可以使用类进行描述。
需求： 使用java类描述 一个婴儿.
在现实生活中有两种婴儿， 一种婴儿一出生就具备了名字(白户)，还有一种婴儿就是 出生之后才有名字 的(黑户)。
构造函数：
构造函数的作用： 给对应的对象进行初始化。
构造函数的定义的格式：
修饰符 函数名(形式参数){
函数体...
}
构造函数要注意的细节：
1. 构造函数 是没有返回值类型的。
2. 构造函数的函数名必须要与类名一致。
3. 构造函数并不是由我们手动调用的，而是在创建对应的对象时，jvm就会主动调用到对应的构造函数。
4. 如果一个类没有显式的写上一个构造方法时，那么java编译器会为该类添加一个无参的构造函数的。
5. 如果一个类已经显式的写上一个构造方法时,那么java编译器则 不会再为该类添加 一个无参 的构造方法。
6. 构造函数是 可以在一个类中以函数重载 的形式存在多个 的。
疑问：创建对象时，jvm就会调用到对应的构造方法，那么我们以前没有学构造方法，那么
以前创建对象时，jvm是否 也会调用构造方法呢？如果有？构造方法从何而来呢？
会调用， java编译器在编译的 时候给加上去的。
jdk提供了一个java开发工具(javap.exe)给我们进行反编译的。
javap 反编译工具的使用格式：
javap -c -l -private 类名
疑问： java编译器添加 的无参构造方法的权限修饰符是 什么？
与类的权限修饰是一致的。
构造函数与普通 函数的区别：
1. 返回值类型的区别：
1. 构造函数是没有返回值类型 的，
2. 普通函数是有返回值类型的，即使函数没有返回值，返回值类型也要写上void。
2. 函数名的区别：
1. 构造函数的函数名必须要与类名一致，
2. 普通函数的函数名只要符合标识符的命名规则即可。
3. 调用方式的区别：
1. 构造函数是 在创建对象的时候由jvm调用的。
2. 普通函数是由我们使用对象调用的，一个对象可以对象多次普通 的函数，
4. 作用上的区别：
1. 构造函数 的作用用于初始化一个对象。
2. 普通函数是用于描述一类事物的公共行为的。
*/
/*
static(静态\修饰符)
1. static修饰成员变量 ：如果有数据需要被共享给所有对象使用时，那么就可以使用static修饰。
静态成员变量的访问方式：
方式1： 可以使用对象进行访问。
格式： 对象.变量名。
方式二： 可以使用类名进行访问。
格式： 类名.变量名;
注意：
1. 非静态的成员变量只能使用对象进行访问，不能使用类名进行访问。
2. 千万不要为了方便访问数据而使用static修饰成员变量，只有成员变量的数据是真正需要被共享的时候
才使用static修饰。
static修饰成员变量的应用场景： 如果一个数据需要被所有对象共享使用的时候，这时候即可好实用static修饰。
2. static修饰成员函数:
*/
/*
static(静态)
需求：描述一下传智学生类。 都是中国人....
目前存在的问题： 所有的学生都是中国 的，有n个学生就会有n份中国的 数据存内存中，这样子
会浪费内存。
目前方案： 把“中国”这个数据移动 到数据共享区中，共享这个数据给所有的Student对象使用即可。
问题2： 如何才能把这个数据移动 到数据共享区中共享呢？
解决方案： 只需要使用static修饰该数据即可。
静态的成员变量只会在数据共享区中维护一份，而非静态成员变量的数据会在每个对象中都维护一份的。。
*/
/*
构造代码块：
构造代码块的作用：给对象进行统一的初始化。
构造函数的作用： 给对应的对象进行初始化。
构造代码块的格式：
{
构造代码块
}
注意： 构造代码块的大括号必须位于成员 位置上。
代码块的类别：
1. 构造代码块。
2. 局部代码块. 大括号位于方法之内。 作用：缩短局部 变量 的生命周期，节省一点点内存。
3. 静态代码块 static
*/
/*
构造 代码块要注意的事项：
1. java编译器编译一个java源文件的时候，会把成员变量的声明语句提前至一个类的最前端。
2. 成员变量的初始化工作其实都在在构造函数中执行的。
3. 一旦经过java编译器编译后，那么构造代码块的代码块就会被移动构造函数中执行，是在构造函数之前执行的，构造函数的中代码是最后执行 的。
4. 成员变量的显示初始化与构造代码块 的代码是按照当前代码的顺序执行的。
*/
/*
构造函数：
构造函数的作用： 初始化对应的对象。
构造函数的格式：
修饰符 函数名(形式参数){
函数体
}
构造函数要注意的事项：
1. 构造函数是没有返回值类型的。
2. 构造函数的函数名是必须与类名一致。
3. 构造函数不是由我们手动调用的，是我们在创建了对应的对象时，jvm会根据你创建的对象传递的参数调用
对应 的对象。
4. 如果一个类没有显示写上一个构造函数的时候，那么java编译器会为该类添加一个无参 的构造函数。
5. 如果一个类已经显示写上一个构造函数的时候,那么java编译器则不会再为该类添加一个无参 的构造函数。
6. 构造函数是可以以函数重载的形式存在多个。
构造代码块：
构造代码块的作用：给对象进行统一的初始化。
构造代码块 的格式：
{
代码；
}
构造代码块是在创建了代码块所属类的对象时调用一次。
this关键字：
this关键字代表了所属函数的调用者对象。
this关键字的作用：
1. 一个类中存在同名的成员变量与局部变量时，在方法的内部默认是访问局部 变量的，可以通过this关键字指定访问成员变量 的数据。
2. this关键字还可以在构造函数中调用另外一个构造函数初始化对象，
this关键字调用构造函数要注意的事项：
1. this关键字调用其他 的构造函数时，必须要是在第一个语句。
2. this关键字调用构造函数时不能出现相互调用，因为是一个死循环。
3. 如果在方法的内部访问一个变量时，该变量只存在于成员变量中，局部没有没有，这时候java编译器会为该变量的前面添加this关键字。
static（静态、修饰符）
static修饰成员变量时：static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.
静态成员变量的访问方式：
方式一： 使用对象进行访问。
对象.属性名
方式二：可以使用类名进行访问。
类名.属性名
注意：
1. 非静态成员变量不能类名直接访问，只能使用对象进行访问。
2. 千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据 时才使用static修饰。
*/
/*
static（静态、修饰符）
static修饰成员变量时：static修饰成员变量时,那么该成员变量的数据就是一个共享的数据.
静态成员变量的访问方式：
方式一： 使用对象进行访问。
对象.属性名
方式二：可以使用类名进行访问。
类名.属性名
注意：
1. 非静态成员变量不能类名直接访问，只能使用对象进行访问。
2. 千万不要为了方便访问成员变量而使用static修饰，一定要是该数据是共享数据 时才使用static修饰。
static修饰方法（静态的成员方法）:
访问方式：
方式一：可以使用对象进行访问。
对象.静态的函数名();
方式二：可以使用类名进行访问。
类名.静态函数名字。
推荐使用是类名直接访问静态的成员。
静态的成员变量与非静态的成员变量的区别：
1. 作用上的区别：
1. 静态的成员变量的作用共享一个 数据给所有的对象使用。
2. 非 静态的成员变量的作用是描述一类事物的公共属性。
2. 数量与存储位置上的区别：
1. 静态成员变量是存储方法 区内存中，而且只会存在一份数据。
2. 非静态的成员变量是存储在堆内存中，有n个对象就有n份数据。
3. 生命周期的区别：
1. 静态的成员变量数据是随着类的加载而存在，随着类文件的消失而消失。
2.非静态的成员数据是随着对象的创建而存在，随着 对象被垃圾回收器回收而消失。
静态函数要注意的事项：
1. 静态函数是可以调用类名或者对象进行调用的，而非静态函数只能使用对象进行调用。
2. 静态的函数可以直接访问静态的成员，但是不能直接访问非静态的成员。
原因：静态函数是可以使用类名直接调用的，这时候可能还没有存在对象，
而非静态的 成员数据是随着对象 的存在而存在的。
3. 非静态的函数是可以直接访问静态与非静态的成员。
原因：非静态函数只能由对象调用，当对象存在的时候，静态数据老早就已经存在了，而非静态
数据也随着对象的创建而存在了。
4. 静态函数不能出现this或者super关键字。
原因：因为静态的函数是可以使用类名调用的，一旦使用类名调用这时候不存在对象，而this
关键字是代表了一个函数 的调用者对象，这时候产生了冲突。
静态的数据的生命周期：静态的成员变量数据是优先于对象存在的。
static什么时候修饰一个函数？
如果一个函数没有直接访问到非静态的成员时，那么就可以使用static修饰了。 一般用于工具类型的方法
静态函数不能访问非静态的成员？
静态函数只要存在有对象，那么也可以访问非 静态的数据。只是不能直接访问而已。
*/
/*
main函数的详解：
public ： 公共的。 权限是最大，在任何情况下都可以访问。 private
原因： 为了保证让jvm在任何情况下都可以访问到main方法。
static: 静态。静态可以让jvm调用main函数的时候更加的方便。不需要通过对象调用。
void: 没有返回值。 因为返回的数据是 给 jvm，而jvm使用这个数据是没有意义的。所以就不要了。
main: 函数名。 注意： main并不是关键字,只不过是jvm能识别的一个特殊的函数名而已。
arguments ：担心某些程序在启动需要参数。
*/
/*
单例设计模式：保证一个类在内存中只有一个对象。
模式：模式就是解决 一类 问题的固定步骤 。
模式的概念最早起源于建筑行业....
建房子的步骤都是一样子：
打地基-----> 浇柱子------->盖楼面--------->砌墙--------->封顶---->装修-----入住
软件行业中23种设计模式：
单例设计模式
模板设计模式
装饰者设计模式
观察者设计模式
工厂设计模式
单例设计模式的步骤：
饿汉单例设计模式
1. 私有化构造函数。
2. 声明本类的引用类型变量，并且使用该变量指向本类对象。
3. 提供一个公共静态的方法获取本类的对象。
懒汉单例设计模式：
1. 私有化构造函数。
2. 声明本类的引用类型变量，但是不要创建对象，
3. 提供公共静态 的方法获取本类 的对象，获取之前先判断是否已经创建了本类 对象
，如果已经创建了，那么直接返回对象即可，如果还没有创建，那么先创建本类的对象，
然后再返回。
推荐使用： 饿汉单例设计模式。 因为懒汉单例设计模式会存在线程安全问题，目前还不能保证一类在内存中只有一个对象。
*/
/*
目前的问题：父类的功能无法满足子类的需求。
方法重写的前提： 必须要存在继承的关系。
方法的重写: 子父类出了同名的函数，这个我们就称作为方法的重写。
什么是时候要使用方法的重写：父类的功能无法满足子类的需求时。
方法重写要注意的事项：
1.方法重写时， 方法名与形参列表必须一致。
2.方法重写时，子类的权限修饰符必须要大于或者等于父类的权限修饰符。
3.方法重写时，子类的返回值类型必须要小于或者 等于父类的返回值类型。
4.方法重写时， 子类抛出的异常类型要小于或者等于父类抛出的异常类型。
Exception(最坏)
RuntimeException(小坏)
方法的重载：在一个类中 存在两个或者两个 以上的同名函数,称作为方法重载。
方法重载的要求
1. 函数名要一致。
2. 形参列表不一致（形参的个数或形参 的类型不一致）
3. 与返回值类型无关。
*/.*
super关键字：
super关键字代表了父类空间的引用。
super关键字的 作用：
1. 子父类存在着同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问父类的成员。
2. 创建子类对象时，默认会先调用父类无参的构造方法，可以通过super关键字指定调用父类的构造方法。
super关键字调用父类构造方法要注意的事项：
1. 如果在子类的构造方法上没有指定调用父类的构造方法，那么java编译器会在子类的构造方法上面加上super()语句。
2. super关键字调用父类的构造函数时，该语句必须要是子类构造函数中的第一个语句。
3. super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。
super关键字与this关键字的区别：
1. 代表的事物不一致。
1. super关键字代表的是父类空间的引用。
2. this关键字代表的是所属函数的调用者对象。
2. 使用前提不一致。
1. super关键字必须要有继承关系才能使用。
2. this关键字不需要存在继承关系也可使用。
3. 调用构造函数的区别：
1. super关键字是调用父类的构造函数。
2. this关键字是调用本类的构造函数。
*/
/*
疑问： 为什么要调用父类的构造方法啊？这样子做的意义在那？
调用父类 的构造方法是可以初始化从父类继承下去的属性的。
*/
/*
instanceof 关键字
instanceof关键字的作用：判断一个对象是否属于指定的类别。
instanceof关键字的使用前提：判断的对象与指定的类别必须要存在继承或者实现的关系。
instanceof关键字的使用格式：
对象 instanceof 类别
instanceof关键字的作用： 目前没用。但是后天我们学习 到了多态之后就非常有用。
一般我们做强制类型转换之前都会使用该关键字先判断一把，然后在进行转换的。
*/
/*
目前存在的问题：
1. 无法描述清楚这两个类之间的继承关系。
2. 存在着重复代码。
面向对象的三大特征：
1. 封装
2. 继承
3. 多态.
继承：继承是通过关键字extends体现的。
继承的格式：
class 类名1 extends 类名2{
}
继承要注意的事项：
1. 千万不要为了减少重复代码而去继承，只有真正存在着继承关系的时候才去继承。
2. 父类私有的成员不能被继承。
3. 父类的构造函数不能被继承。
4. 创建子类对象时默认会先调用父类无参的构造函数。
*/
/*
static（静态、修饰符）
static修饰成员变量: 如果一个成员变量使用static修饰，那么该成员变量的数据就是一个共享 的数据.,、
静态成员变量的访问方式
方式一：可以使用对象访问。
对象.属性名
方式二：可以使用类名访问。
类名.属性名
注意：
1. 非静态成员变量不能使用类名直接访问，要使用对象访问.
2. 千万不要为了访问方便而使用static修饰。一定要数据真正是需要被共享的时候才使用static修饰。
static修饰成员函数:
静态函数的访问方式
方式一：可以使用对象访问。
对象.属性名
方式二：可以使用类名访问。
类名.属性名
推荐使用类名访问静态的成员。
静态函数要注意的细节：
1. 非静态函数只能由对象调用，静态函数可以由类名或者对象进行调用。
2. 静态函数中不能直接访问非静态成员，可以直接访问静态的成员。
3. 非静态函数可以直接访问非静态成员以及可以直接访问静态的成员。
4. 静态函数中不能出现this或者super关键字。
单例设计模式：保证一个类在内存中只有一个对象。
饿汉单例设计模式：
1. 私有化构造函数。
2. 声明本类的引用类型变量并且指向本类的对象，(private static)
3. 提供一个公共静态的方法获取本类对象。
懒汉单例设计模式:
1. 私有化构造函数。
2. 声明本类的引用类型变量，但是不要创建对象。
3. 提供一个公共静态的方法获取本类对象，获取之前先判断是否已经创建了本类的对象，
如果没有创建，创建再返回。如果已经创建了，那么直接访问即可。
继承：
继承的格式:
class 类名1 extends 类名2{
}
继承要注意的事项：
1. 父类私有的成员不能被继承。
2. 父类的构造函数不能被继承。
3. 创建子类对象时，默认会先调用父类的无参构造函数，然后再调用子类 的构造函数。
super关键字：super关键字代表的是父类的引用空间。
super关键字的作用：
1. 如果子父类存在同名的成员时，在子类中默认是访问子类的成员，可以通过super关键字指定访问 父类的成员。
2. 创建子类对象时，默认会先调用父类的无参构造函数，可以通过super关键字指定调用父类的构造函数，
super关键字要注意的事项：
1. 如果在子类 的构造函数中没有指定调用具体父类构造函数，那么java编译器会在子类的构造函数上添加super()语句。
2. super关键字调用构造函数时必须出现构造函数中第一个语句。
3. this与super调用构造函数的时候不能同时出现在一个构造函数中，因为都需要是第一个语句。
方法重写：子父类存在着同名的函数。
方法重写的需求： 如果父类的功能无法满足子类的需求，那么就进行重写。
方法重写的要素：
1. 函数名与形参列表必须一致。
2. 子类的权限修饰符必须大于或者等于父类 的权限 修饰符。
3. 子父类的返回值类型必须小于或者等于父类的返回值类型。
4. 子类抛出的异常类型必须要小于或者等于父类抛出的异常类型。
instanceof：判断一个对象是否属于某种类型。
instanceof关键字的使用格式：
对象 instanceof 类。
instanceof的使用前提：判断的对象与类型必须存在继承或者实现的关系。
*/
/*
final(最终、修饰符)
final关键字的用法：
1. final关键字修饰一个基本类型的变量时，该变量不能重新赋值，第一次的值为最终的。
2. fianl关键字修饰一个引用类型变量时，该变量不能重新指向新的对象。
3. final关键字修饰一个函数的时候，该函数不能被重写。
4. final关键字修饰一个类的时候，该类不能被继承。
常量 的修饰符一般为： public static final
*/
/*
抽象类：
目前存在的问题：
1. 动物类的run方法描述的不正确。
2. 没有强制要子类一定要重写run方法。
抽象类的应用场景：
我们在描述一类事物的时候，发现该种事物确实存在着某种行为，
但是这种行为目前是不具体的，那么我们可以抽取这种行为 的声明，但是
不去实现该种行为，这时候这种行为我们称作为抽象的行为，我们就需要使用抽象类。
抽象类的好处: 强制要求子类一定要实现指定的方法。
抽象类要注意的细节：
1. 如果一个函数没有方法体，那么该函数必须要使用abstract修饰,把该函数修饰成抽象 的函数。。
2. 如果一个类出现了抽象的函数，那么该类也必须 使用abstract修饰。
3. 如果一个非抽象类继承了抽象类，那么必须要把抽象类的所有抽象方法全部实现。
4. 抽象类可以存在非抽象方法，也可以存在抽象的方法.
5. 抽象类可以不存在抽象方法的。
5. 抽象类是不能创建对象的。
疑问：为什么抽象类不能创建对象呢？
因为抽象类是存在抽象方法的，如果能让抽象类创建对象的话，那么使用抽象的对象
调用抽象方法是没有任何意义的。
6. 抽象类是存在构造函数的，其构造函数是提供给子类创建对象的时候初始化父类的属性的。
*/
/*
需求： 描述一个图形、圆形、 矩形三个类。不管哪种图形都会具备计算面积
与周长的行为，但是每种图形计算的方式不一致而已。
常量的命名规范：全部字母大写，单词与单词 之间 使用下划线分隔。
abstract不能与以下关键字共同修饰一个方法：
1. abstract不能与private【私有】共同修饰一个方法。
2. abstract 不能与static【静态】共同修饰一个方法。
3. abstract 不能与final【最终】共同修饰一个方法。
*/
/*
值传递: 调用一个方法的时候，传递给方法的参数 ，实际上传递变量所存储的值。
*/
/*
接口：
接口：拓展功能的。 usb接口.。。
接口的定义格式：
interface 接口名{
}
接口要注意的事项 ：
1. 接口是一个特殊的类。
2. 接口的成员变量默认的修饰符为： public static final 。那么也就是说接口中的成员变量都是常量。
3. 接口中 的方法都是抽象的方法，默认的修饰符为： public abstract。
4. 接口不能创建对象。
5. 接口是没有构造方法的。
6. 接口是给类去实现使用的，非抽象类实现一个接口的时候，必须要把接口中所有方法全部实现。
实现接口的格式：
class 类名 implements 接口名{
}
*/
/*
一个类最多只能有一个直接的父类。但是有多个间接的父类。
java是单继承。
*/
/*
接口的作用：
1. 程序的解耦。 （低耦合）
2. 定义约束规范。
3. 拓展功能。
*/
/*
需求：在现实生活中有部分同学在学校期间只会学习，但是有部分学生除了学习外还会赚钱。
interface （定义接口）
implements (实现接口)
分析：
普通的学生类
接口
会挣钱的学生
*/
/*
类与接口之间关系： 实现关系。
类与接口要注意的事项：
1. 非抽象类实现一个接口时，必须要把接口中所有方法全部实现。
2. 抽象类实现一个接口时，可以实现也可以不实现接口中的 方法。
3. 一个类可以实现多个接口 。
疑问： java为什么不支持多继承，而支持了多实现呢？
class A{
public void print(){
System.out.println("AAAAAA");
}
}
class B{
public void print(){
System.out.println("BBBBBB");
}
}
class C extends A ,B{
}
new C().print();
接口与接口之间关系： 继承关系。
接口与接口之间要注意事项：
1. 一个接口是可以继承多个接口的。
*/
/*
面向对象的三大特征：
1. 封装
2. 继承。
3. 多态
多态：一个对象具备多种形态。(父类的引用类型变量指向了子类的对象)
或者是接口 的引用类型变量指向了接口实现类的对象)
多态的前提：必须存在继承或者实现 关系。
动物 a = new 狗();
多态要注意 的细节：
1. 多态情况下，子父类存在同名的成员变量时，访问的是父类的成员变量。
2. 多态情况下，子父类存在同名的非静态的成员函数时，访问的是子类的成员函数。
3. 多态情况下，子父类存在同名的静态的成员函数时，访问的是父类的成员函数。
4. 多态情况下，不能访问子类特有的成员。
总结：多态情况下，子父类存在同名的成员时，访问的都是父类的成员，除了在同名非静态函数时才是访问子类的。
编译看左边，运行不一定看右边。
编译看左边：java编译器在编译的时候，会检查引用类型变量所属的类是否具备指定的成员，如果不具备马上编译报错。
*/
/*
多态的应用：
1. 多态用于形参类型的时候，可以接收更多类型的数据 。
2. 多态用于返回值类型的时候，可以返回更多类型的数据。
多态的好处： 提高了代码的拓展性。
需求1： 定义一个函数可以接收任意类型的图形对象，并且打印图形面积与周长。
*/
/*
抽象类：
什么是时候使用抽象类：
描述一类事物的时候，发现该事物确实存在着某种 行为，但是 目前这种
是不具体的，这时候应该抽取这种行为的声明，而不去实现该种行为，这时候
这种行为我们把它称为抽象的行为，这时候应该使用抽象类。
抽象类要注意的细节：
1. 如果一个方法没有方法体，那么该方法必须使用abstract修饰。
2. 如果一个类函数抽象方法，那么这个类肯定是一个抽象类或者接口。
3. 抽象类不能创建对象。
4. 抽象类是含有构造方法的。
5. 抽象类可以存在非抽象方法与抽象方法。
6. 抽象类可以不存在抽象方法。
7. 非抽象类继承抽象类的时候，必须要把抽象类中所有抽象方法全部实现。
abstract不能与以下关键字一起使用
1.abstract 不能与static共同修饰一个方法。
2. abstract 不能与private共同修饰一个方法。
3. abstract不能以final关键字共同修饰一个方法。
接口：
接口的定义格式：
interface 接口名{
成员变量
成员函数..
}
接口的作用：
1. 程序解耦。
2. 定义约束规范
3. 拓展功能。
接口要注意的细节：
1. 接口中成员变量都是常量，默认 的修饰符是 public static fianl.
2. 接口中的方法全部都是抽象的方法，默认的修饰符： public abstract。
3. 接口不能创建对象。
4. 接口是没有构造函数 的。
5. 非抽象类通过implements实现接口的时候，必须要把接口中所有方法全部实现。
接口与类之间 的关系： 实现关系。
注意： 一个类可以实现多个接口。
接口与接口之间的关系： 继续关系。
注意： 一个接口是可以继承多个接口的。
多态：父类的引用类型变量指向了子类的对象，或者是接口的引用类型变量指向了接口实现类的对象。
多态要注意细节：
1. 多态情况下，如果子父类存在同名的成员变量时，访问的是父类的成员变量.
2. 多态情况下，如果子父类存在同名的非静态函数时，访问的是子类 的成员函数。
3. 多态情况下，如果子父类存在同名的静态函数时，访问的是父类的成员函数。
4. 多态情况下， 不能访问子类特有的成员。
多态的应用：
1.多态用于形参类型的时候，可以接收更多类型的数据
2. 多态用于返回值类型的时候，可以返回更多类型的数据.
*/
/*
局部内部类： 在一个类 的方法内部定义另外一个类，那么另外一个类就称作为局部内部类。
局部内部类要注意的细节：
1. 如果局部 内部类访问了一个局部变量，那么该局部变量必须使用final修饰、
*/
/*
匿名内部类：没有类名的类就称作为匿名内部类。
匿名内部类的好处：简化书写。
匿名内部类的使用前提：必须存在继承或者实现关系才能使用。
匿名内部类一般是用于实参。
*/
/*
异常：
我们的java程序也是会存在某些不正常 的情况的，这些不正常的 情况我们就统称异常。
异常体系：
--------| Throwable
------------| Error
------------| Exception
Throwable常用的方法：
toString() 返回当前异常对象的完整类名+病态信息。
getMessage() 返回的是创建Throwable传入的字符串信息。
printStackTrace() 打印异常的栈信息。
*/
/*
异常的体系：
----------| Throwable 所以异常或者错误类的超类
--------------|Error 错误 错误一般是用于jvm或者是硬件引发的问题，所以我们一般不会通过代码去处理错误的。
--------------|Exception 异常 是需要通过代码去处理的。
如何区分错误与异常呢：
如果程序出现了不正常的信息，如果不正常的信息的类名是以Error结尾的，那么肯定是一个错误。
如果是以Exception结尾的，那么肯定就是一个异常。
*/
/*
疑问： 下面的信息是通过printStackTrace方法打印出来，那么异常对象从何而来呢？
Exception in thread "main" java.lang.ArithmeticException: / by zero
at Demo10.div(Demo10.java:10)
at Demo10.main(Demo10.java:5)
jvm运行到a/b这个语句的时候，发现b为0，除数为0在我们现实生活中是属于
不正常的情况，jvm一旦发现了这种不正常的情况时候，那么jvm就会马上创建
一个对应的异常对象，并且会调用这个异常对象 的printStackTrace的方法来处理。
异常的处理：
方式一：捕获处理
捕获处理的格式：
try{
可能发生异常的代码；
}catch(捕获的异常类型 变量名){
处理异常的代码....
}
捕获处理要注意的细节：
1. 如果try块中代码出了异常经过了处理之后，那么try-catch块外面的代码可以正常执行。
2. 如果try块中出了异常的代码，那么在try块中出现异常代码后面的代码是不会执行了。
3. 一个try块后面是可以跟有多个catch块的，也就是一个try块可以捕获多种异常的类型。
4. 一个try块可以捕获多种异常的类型,但是捕获的异常类型必须从小到大进行捕获，否则编译报错。
疑问一 : 异常的处理感觉没有多大作用，因为都是输出一个话而已?
异常处理非常有用，只不过是由于我们目前所接触的知识点太过于局限而已。
疑问二： 以后捕获处理 的时候是否就是捕获Exception即可？
错的，因为我们在现实开发中遇到不同的异常类型的时候，我往往会有不同 的处理方式。
所以要分开不同的异常类型处理。
*/
/*
异常的处理方式----抛出处理
抛出处理（throw throws）
抛出处理要注意的细节：
1. 如果一个方法的内部抛出了一个异常 对象，那么必须要在方法上声明抛出。
2. 如果调用了一个声明抛出异常 的方法，那么调用者必须要处理异常。
3. 如果一个方法内部抛出了一个异常对象，那么throw语句后面的代码都不会再执行了（一个方法遇到了throw关键字，该方法也会马上停止执行的）。
4. 在一种情况下，只能抛出一种类型异常对象。
throw 与throws两个关键字：
1. throw关键字是用于方法内部的，throws是用于方法声声明上的。
2. throw关键字是用于方法内部抛出一个异常对象的，throws关键字是用于在方法声明上声明抛出异常类型的。
3. throw关键字后面只能有一个异常对象，throws后面一次可以声明抛出多种类型的 异常。
疑问：何时使用抛出处理？何时捕获处理？原则是如何？
如果你需要通知到调用者，你代码出了问题，那么这时候就使用抛出处理.
如果代码是直接与用户打交道遇到了异常千万不要再抛，再抛的话，就给了用户了。
这时候就应该使用捕获处理。
*/
