获取一个任意范围（n~m）之间的随机整数（int型）：
int num = (int)(Math.random()*(m-n+1)+n);
注释分三种：
1，// 单行注释
2，/* xx */多行注释
3，/** xx */ 文档多行注释 （放在代码最顶部，作用是当光标悬于代码上时可显示文本内容）
输出 system.out.println()输出并换行
自动关机程序：用Runtime函数调用getRuntime来获得java的始环境，并调用exec（"shutdown -s -t 3600"），执行便可。如果要终止程序则运行Runtime.getRuntime().exec（"shutdown -a")
变量：
系统为程序分配的一块内存单元，可存储各种类型的数据，数值可变
分类：
按所属的数据类型划分：1.基本数据类型；2.引用数据类型。
按被声明的位置划分：1.
局部变量：方法或语句块内部定义的变量
成员变量：方法外部、类内部
数据类型：
基本数据类型：数值型（整数型：byte【1字节】--值范围（-128~127）,char【2】 short【2字节】,int【4字节】,long【8字节】非整型：float【4字节】,double【8字节】）和布尔型(boolean【1字节】)
引用数据类型：类（class）,接口（interface）,数组
标识符（见名知意）：JAVA对包、类、方法、参数、变量命名时使用的字符序列
·由字母、数字、下划线（_）和美元符号组成
·不能以数字开头
·区分大小
·长度无限制
·不能是保留字
数据类型转换（强制转换可能造成精度丢失问题）：
自动类型转换：容量小的类型自动转换成容量大的数据类型;
强制类型转换：容量大的类型转换成容量小的数据类型时，要加上强制转换符，例：b = (byte)i .
方法：用于封装一段特定的逻辑功能。主要要素：权限修饰符、方法名、参数列表和返回值
格式：
权限修饰符 返回值类型声明 方法名称（参数列表）{
方法中封装的逻辑功能
return 返回值
}
权限修饰符：private(同一个类)、默认（同一个类，同包）、protected(同类，同包，不同包子类)
返回值：方法调用结束之后可返回一个数据，称为返回值，方法必须声明返回值类型通过return返回，若无则声明为void。
（static修饰的内容加载的比较早）
float类型变量在定义时需注意；直接写出来的浮点数，默认类型是double，会提示需强制转换
解决：可在浮点数子后家f，来表示写出的数字类型是float
long类型变量定义需注意，直接写出来的是整形数字，默认类型是int，当值过大时会提示出错
解决：在整形数字后加l，来表示写出的整形数字是long类型的
char赋值时需加''
三目运算符： a<b?y:z 如果运算式的结果为真则执行‘y’,为假则执行‘z’
\n 换行，将当前位置移到下一行开头
\r 回车，将当前位置移到本行开头
\t制表符 \转义符
如何接收用户的键盘输入：
Scanner(类型) input（变量） = new Scanner(System.in) [system.in扫描输入系统的数据]
String i = input.next() next中还有nextint(),nextfloat()等接收对应的各种类型的代码
可接收任何类型的数据：input.next()不能接收空格，空格为结束输入的标志 input.nextline()能接收空格，以回车结束
两方法不可同时使用，两个方法接收的数据类型都为字符串
switch(表达式){
case取值1:语句块1;break;
case取值n:语句块n;break;
default:语句块n+1;break;//default子句是可选的；
}
switch语句有关规则 表达式的返回值必须是下述几种类型之一：int,byte,char,short,String；
case子句中的取值必须是常量，且所有case子句中的取值应是不同的；
break语句用来在执行完一个case分支后使程序跳出switch语句块；
如果case后面没有写break则直接往下面执行！ Case后面的执行体可写{}也可以不写{}
如果任何一个都不满足则直接跳过switch语句，不执行任何一个case
外层循环控制的是行数，内层循环控制的列数
break与contiune 语句区别：
break是用于终止本轮所有次循环，即不执行本次循环中break后面的语句，直接跳出循环；
contiune是用于终止本轮本次循环，即本次循环中contiune后面的代码不执行，进行下一次循环的入口判断。
例子：for(int i=0;i<10;i++){
if(i==5){
break/contiune; //如果是break则打印出 0.1.2.3.4
} 如果是contiune则打印出 0.1.2.3.4.6.7.8.9
system.out.println(i);
}
如何退出多重循环：
在最外层循环前面加上别名，如： fuxk:for(;;){ for(;;){ break fuxk; } } 便可直接退出多重循环
DAY03
数组：数组是相同数据类型的多个数据的容器
格式1. 数据类型[] 数组名称 = new 数据类型[数组长度];
格式2. 数据类型[] 数组名称 = {数组内容1,数组内容2,数组内容3...数组内容n};
使用数组不当， 会出现如下问题：
数组未赋值：
空指针异常 超出长度的下标操作：
数组越界异常 注意：（若发生程序崩溃，后面代码不执行）
数组的长度在创建时就固定了。
升序排列的口诀:
N个数字来排队
两两相比小靠前,
外层 循环length-1
内层循环length-i-1
break 跳出当前循环执行后续代码
return 结束当前方法
回合制游戏如：五子棋，判断语句多用if..else ；判断条件只能一方进行。
面向对象：面向对象是相对于面向过程来讲的，指的是把 相关的数据和方法组织为一个整体 。
面向过程到面向对象，是程序员思想上 从执行者到指挥者的转变。
类表示一个共性的产物，是一个综合的特征，而对象，是一个个性的产物，是一个个体的特征。 （类似生活中的图纸与实物的概念。）
对象的创建和使用：//注意不要写到另一个类的里面
类名称 对象名称 = new 类名称() ;
方法的定义格式：
返回值类型 方法名称（形式参数列表）{
方法体
return 返回值;
}
访问类中的属性或方法：
访问类中的属性： 对象.属性 ;
调用类中的方法： 对象.方法(实际参数列表) ;
特殊案例：
void xxx(){ //虽然这里返回值类型为空，但依旧用了return ，return用
if(true){ 法是结束这个方法，当执行了return后，后续
return; 的程序将不再执行，这里就不会打印123
}
sysstem.out.print("123");
}
一个类中的方法是允许重载的（相同的方法名称）：
1、方法名称相同；
2、参数列表长度 或 参数列表类型 或（参数类型顺序不同）
例子：double sum(int x,double y) {//传递来的实参类型必须与方法中的相同。
double z = x+y;
return z;
}
double sum(double y,int x) {
double z = x+y;
return z;
}
匿名对象：匿名对象只能使用一次，因为没有任何的对象引用，所以将称为垃圾，等待被G·C回收
面向对象进阶
封装private:为了避免出现逻辑错误， 我们建议对所有属性进行封装，并为其提供setter及getter方法进行设置和取得操作，快捷键：SHIFT+ALT+S
this (指当前对象)
· 调用类中的属性
· 调用类中的方法或构造方法 （在一个构造方法中，调用另一个构造方法时，调用的代码必须编写在构造方法的第一行）
· 表示当前对象
例子：person p3 = new person();
xxxxx
//这里无参的person调用了当前类中有两参的方法，this类似于p3，可调用p3调用的
person(){
this("默认"，18)；
}
static(静态)：可以用来修饰成员变量和成员方法(
static的主要作用在于创建独立于具体对象的域变量或者方法
并且不会因为对象的多次创建 而在内存中建立多份数据
被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问
1.静态成员 在类加载时加载并初始化。
2.无论一个类存在多少个对象 , 静态的属性, 永远在内存中只有一份( 可以理解为所有对象公用 )
3. 在访问时：静态不能访问非静态 ，非静态可以访问静态
代码块：
普通代码块 在执行的流程中出现的代码块， 我们称其为普通代码块
构造代码块 在类中的成员代码块， 我们称其为构造代码块， 在每次对象创建时执行， 执行在构造方法之前。构造代码块与构造方法的区别：无论用户调用哪个构造方法来创建对象，构造代码块都会执行
静态代码块 在类中使用static修饰的成员代码块， 我们称其为静态代码块， 在类加载时执行。 每次程序启动到关闭，因为类只加载一次，所以静态代码块只执行一次。
同步代码块
执行顺序：静态代码块-->构造代码块-->构造方法
包：
1、把功能相同的类或接口组织在同一个包中，方便类的查找和使用。
2、包如同文件夹一样，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。包可以避免名字冲突
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
包中.java文件的定义：在.java文件的首部，必须编写类所属哪个包，格式：packge 包名
包的定义：通常由多个单词组成，所有单词的字母小写，单词与单词之间用.隔开，一般命名为“com.公司名.项目.模块...”。
import :
import 包名.类名;
Day07.14
继承：继承就是子类继承父类的特征和行为，使得子类对象（实例）
具有父类的实例域或方法，或子类从父类继承方法，使得子类具有父类的相同的行为。
格式：
class父类{
}
class 子类 extends 父类{
}
继承的限制：
Java中只有单继承，多重继承（类似于孙父爷的关系）例子：C->B,B->A
super（）关键字
通过super，可以访问父类构造方法；
通过super构造方法的代码，必须写在子类构造方法的第一行；super();
通过super，可以访问父类的属性；super.sex = "";
通过super，可以访问父类的方法 super.setName = "";
重写(override)、重载(overload)
重写（override）：用于父的方法不适用于子时，才需要重写
1、参数列表必须完全与被重写的方法相同；
2、返回值类型必须完全与被重写方法的返回类型相同，如果父类无返回，子类重写的也必须无返回；
3、访问权限不能比父类中被重写的方法的访问权限更低，例如：若父类的一个方法被声明为public，那么在子类中重写该方法就不能被声明为protected
4、父类的成员方法只能被它的子类重写
5、声明为static和private的方法不能被重写，但能够被再次声明。
重载（overload）：发生在一个类当中，方法名相同功能不同。
区别：
1、发生的位置
重载：一个类中；
重写：子父类中
2、返回值类型
重载：与返回值类型无关；
重写：返回值类型必须一致
3、参数列表限制
重载：必须不同的
重写：必须相同的
4、访问权限
重载：与访问权限无关
重写：子的方法的权限不能小于父的方法权限
5、异常处理
重载：于异常无关
重写：异常范围可以更小，但不能抛出新的异常
final关键字：
final用于修饰属性、变量
变量成为了常量，无法对其再次进行赋值
final修饰的局部变量，只能赋值一次（可以先声明后赋值）
final修饰的成员属性，必须在声明时赋值
final用于修饰类：
final修饰的类，不可以被继承；
final用于修饰方法：
final修饰的方法，不能被子类重写
全局常量（piblic static final）static代表可通过类名直接访问
常量的命名规范：
由1个或多个单词组成，单词与单词之间必须使用下划线隔开，单词中所有字母大写，例如：SQL_INSERT
抽象类：必须用abstract class 声明，一个抽象类中可以没有抽象方法，抽象方法必须写在抽象类或接口中。
格式：
abstract class 类名{//抽象类
}
抽象方法：只声明未实现的方法称为抽象方法（未实现指：没有“{}”方法体），抽象方法必须用abstract关键字声明
格式：
abstract class 类名{//抽象类
public abstract void 方法名（）;//抽象方法，只声明未实现
}
不能被实例化：
使用原则：· 抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
·一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全部抽象方法
常见问题：
1、抽象类能否用final声明？
不能，因为final修饰的类不能有子类，二抽象类必须有子类才有意义
2、抽象类能否有构造方法？
能，子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的构造方法（默 认是无参的），之后再调用子类自己的构造方法。
抽象类与普通类的区别：
1、、抽象类必须用public或protected修饰(如果为private修饰，那么子类则无法继承，也就无法实现其抽象方法）。 默认缺省为 public
2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化
3、、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为 abstract类
接口：如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。
格式：
interface 接口名称{
全局常量；
抽象方法；
}
面向接口编程思想：这种思想是接口定义（规范、约束）与实现（名实分离的原则）的分离
优点：
1、降低程序的耦合性；
2、易于程序的扩展；
3、有利于程序的维护
全局常量和抽象方法的简写：
1、全局常量编写时，可以省略public static final 关键字，
例如：public static final String INFO = "内容" ;
简写后：String INFO = "内容" ;
2、抽象方法编写时，可以省略 public abstract 关键字， 例如： public abstract void print() ;
简写后： void print() ;
接口的实现implements：
接口可以多实现：
格式：
class 子类 extends 父接口1，父接口2...{
}
一个类即要实现接口，又要继承抽象类的话：
格式：
class 子类 extends 父类 implements 父接口1，父接口2...{
}
接口的继承：接口因为都是抽象部分，不存在具体的是实现，所以允许多继承
interface C extends A,B{
}
注意：若一个接口想使用，必须依靠子类。子类（若不是抽象类）要实现接口中的所有抽象方法。
接口和抽象类的区别：
1、抽象类要被子类继承，接口要被类实现；
2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法
3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量
4、抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现
5、抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明静态方法）
6、接口不能有构造方法，但是抽象类可以有
多态：是对象的多种表现形式（多种体现形态）
多态的体现：
对象的多态性：在类中有子类和父类之分，子类就是父类的一种形态，对象多态性就从此而来。
PS：方法的重载 和 重写 也是多态的一种，不过是方法的多态（相同方法名的多种形态）
重载：一个类中方法的多态性体现；
重写：子父类中方法的多态性体现
多态的使用：对象的类型转换
类似于基本数据类型的转换：
·向上转型：将子类实例变为父类实例
格式：父类 父类对象 = 子类实例；
·向下转型：将父类实例转为子类实例
格式：子类 子类对象 = （子类）父类实例；
instanceof
作用：判断某个对象是否是指定类的实例，则可以使用instanceof关键字
格式：
实例化对象 instanceof 类//此操作返回boolean 类型的数据
Object类
概念： Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object类
例如：我们定义的类：
public class Person{
}
其实被用到会时时：
public class Person extends Object{
}
Object的多态
使用Object可以接收任意的引用数据类型
toString ：返回对象的字符串表示形式。
在对象不声明的情况下默认为Object类，直接打印为输出toString (),返回对象的内存地址
equals：Object中的equals（Object obj）方法中比的是两对象的内存地址是否相同，只有内存地址相同才返回true
自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。
对称性 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。
传递性 ：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true ，然后 x.equals(z)应该返回true 。
一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前提是未修改对象 上的equals比较中使用的信息。
非空性 ：对于任何非空的参考值x ， x.equals(null)应该返回false
内部类：将一个类定义在另一个类或方法里面。（成员内部类、局部内部类、匿名内部类、静态内部类）
成员内部类： 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）。
不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问 的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法
外部使用成员内部类
Outter outter = new Outter（）；
Outter.Inner inner = outter.new Inner();
局部内部类：
局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或 者该作用域内
注意:局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的
匿名内部类：
格式：
new 父类构造器（参数列表）| 实现接口（）
{
//匿名内部类的类体部分
}
因为匿名内部类是直接使用new来生成一个对象的引用。当然这个引用是隐式的
注意：
1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或 者实现一个接口。
2、匿名内部类中是不能定义构造函数的。
3、匿名内部类中不能存在任何的静态成员变量和静态方法。
4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效
5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。 6、只能访问final型的局部变量
静态内部类
静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。 静态内部类是不需要依赖于外部类对象的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员 变量或者方法
包装类：八种包装类：
·Number：Integer、Short、Long 、Double、Float、Byte都是Number的子类表示是一个数字
·Object：Character、Boolean都是Object的直接子类
字符串转换：使用包装类还有一个很优秀的地方在于：可以将一个字符串变为指定的基本数据类型，此点一般在接收输入数据上使用 较多
在Integer类中提供了以下的操作方法：
public static int parseInt(String s) ：
将String变为int型数据 在Float类中提供了以下的操作方法：
public static float parseFloat(String s) ：
将String变为Float 在Boolean 类中提供了以下操作方法：
public static boolean parseBoolean(String s) ：
将String变为boolean
可变参数： 可以根 据需要自动传入任意个数的参数
语法：
返回值类型 方法名称（数据类型... 参数名称）{
//参数在方法内部，以数组的形式来接收
}
注意：可变参数只能出现在参数列表的最后。
