Java学习笔记（二）——面向对象编程
一、面向对象的概念
在计算机编程中，我们可以把现实生活中的一切事物视为对象，而事物产生变化的动作我们视为对象实现某种目的的方法。
通过将不同的对象按照其属性进行分类，从而具体化任何一个对象的实例，在这里，实例是某一对象的具体表现形式，例如，如果我们创建一个名为Person的类，用来代表人类，那么在这个Person类中，可以创建两个实例：Man和Women分别代表男人和女人，那么Man和Women就分别是Person的具体化表现形式，他们都拥有相同的类型Person，但是自身却拥有不同的属性。
在Java编程中，我们把现实生活中的概念进行抽象，生成计算机模型，然后引导和操作Java对象，从而将虚拟与现实完美的联系起来，实现我们编程的目的。
（一）类（class）
1.class定义了如何创建实例
2.class的名字就是数据的类型
（二）实例（instanse）
1.instanse是根据class创建的实例，也就是数据本身
2.可以同时创建多个instanse
3.每一个instanse的类型相同，但是其各自拥有的属性也许是不同的
4.指向instanse的变量都是引用变量
5.每一个instanse都拥有独立的存储空间，修改不同的instanse互不影响
（三）定义class
在编写代码的过程中，我们首先需要定义class。在一个class中可以包含多个字段（field）用来描述class的特征，从而实现了class的数据封装
public class Person {//定义名为Person的class
public String name;//定义一个String类型的name属性
public int age;//定义一个int类型的age属性
}//完成名为Person的class定义（四）创建instanse
在我们完成了class的定义之后，就可以创建instanse实例
1.使用new操作符创建一个实例
2.定义一个引用类型变量来指向实例
3.通过变量操作实例
4.通过 变量.字段 来访问实例
Person zero = new Person();//创建实例
zero.name = "零";//定义引用类型指向实例
zero.age = 25;//操作实例
System.out.println(zero.name);//访问字段二、数据封装
（一）方法
1 . 数据封装的作用
在定义class时，可以让class包含多个field，但是直接将field用public暴露给外部可能会破坏封装为了避免外部代码直接修改class内部的数据，我们使用private来修饰field，以此来拒绝外部访问。
public：外部代码可以访问该字段
private：外部代码无法访问该字段
public class Person {
private String name;
private int age;
public void setName(String name){
this.name = name;//通过setName()来修改name字段
}
public String getName(){/
return this.name;//通过getName()来读取name字段
}
} 2 . 封装方法
（1）外部代码不可访问private
（2）外部代码通过调用public方法间接的设置和获取private字段
（3）public方法封装了外部访问
（4）通过方法访问实例字段更加安全
（5）通过 变量.方法名() 来调用实例方法
Person zero = new Person();
zero.name = "零";//编译错误
zero.age = 25;//编译错误
zero.setName("零");//调用setName()方法修改name字段
System.out.println(zero.getName());//调用getName方法读取name字段
3 . 定义方法
（1）方法的定义：
①public修饰符
②方法的返回值
③方法名称（需要遵循Java命名规范）
④方法参数列表
⑤方法的返回值通过return语句实现
⑥没有返回值(void)可以省略return
⑦方法内部可以使用隐式变量this，this指向当前实例，this.field可以访问当前字段的实例
public class Person {
private String name;
private int age;
public String getName(){//public修饰词 方法返回值 方法名称 方法参数列表
return this.name;//在方法内部使用隐式变量this
}
public void setName(String name){
if(name == null){
throw new NullPointException();
}
this.name = name.trim();
}
}（2）隐式变量this
①方法内部可以使用隐式变量this
②this指向当前实例
③this.field可以访问当前字段的实例
④在不引起歧义的情况下可以省略this
public String getName(){//public修饰词 方法返回值 方法名称 方法参数列表
return name;//return this.name
}⑤当字段名和局部变量名重名时，编译器优先查找局部变量名
public void setName(String name){
if(name == null){
throw new NullPointException();
}
this.name = name.trim();//优先执行局部变量名
}（3）调用方法
在定义好一个方法后，可以进行该方法的调用
①使用 实例变量.方法名(参数) 格式
②可以忽略方法的返回值
Person zero = new Person();
zero.setName("零");//没有返回值
String s = zero.getName();//返回值为String
4 . 方法参数
（1）方法参数是用于接收传递给方法的变量值，在调用方法时，通过外部代码把一个变量通过参数传递给方法内部
（2）参数绑定：
（3）private方法：可以通过定义private方法，让外部代码无法访问private方法，而内部代码可以调用自己的private方法
（二）构造方法Constructor
在前面的内容中，如果需要创建实例并进行初始化，需要以下3行代码：
Person zero = new Person();//使用new操作符创建实例
zero.setName("零");//初始化字段
zero.setAge(25);//初始化字段那么我们能否在创建实例的同时就把内部字段初始化为合适的值呢？
例如：
Person zero = new Person("零",25);1 . 如何构造方法
（1）可以在创建对象实例的时候初始化方法
（2）而实例在创建时会调用构造方法
（3）构造方法用于初始化实例
public class Person {
private String name;
private int age;
public Person(String name, int age){//构造方法名：Person
this.name = name;
this.age = age;
}
}
（4）构造方法名就是类名
（5）构造方法的参数没有限制
（6）构造方法没有返回值也没有void
（7）必须用new操作符调用构造方法
（8）如果一个类没有定义构造方法，编译器会自动生成一个默认的构造方法()，没有参数和执行语句
2 . 如何初始化构造方法
（1）先初始化字段
（2）没有赋值的字段初始化为默认值（基本类型为0，引用类型为null）
（3）再执行构造方法的代码
public class Person {
private String name = "Unnamed";//初始化字段
private age;//没有赋值的字段初始化为默认值
public Person(String name, int age){//定义构造方法
this.name = name;//构造方法代码
this.age = age;//构造方法代码
}
}3 . 定义多个构造方法
（1）可以同时定义多个构造方法，编译器通过构造方法的参数数量、位置和类型进行区分
public class Person {
private String name;
private int age;
public Person(String name int age){//new Person("zero",25)
this.name = name;
this.age = age;
}
public Person(String name){//new Person("zero")
this.age = 18;
}
public Person(){//new Person()
}
}（2）一个构造方法可以使用this(…)调用其他构造方法，目的是便于代码复用
public class Person {
private String name;
private int age;
public Person(String name int age){
this.name = name;
this.age = age;
}
public Person(String name){
this(name,25);//调用构造方法
}
public Person(){
this("Unnamed");//调用构造方法
}
}（三）方法重载Overload
1 . 方法重载的概念
方法重载是指：
（1）多个方法的方法名相同
（2）各自方法的参数不同
——参数个数不同
——参数类型不同
——参数位置不同
（3）方法的返回值类型通常相同
例如：
public class Hello {
public void hello(String name){
}
public void hello(int age){
}
public void hello(String name, int age){
}
public void hello(int age, String name){
}
}2 . 方法重载的目的
重载的目的是让相同功能的方法使用同一名字，便于方法的调用
public class Hello {
public static void main(String[] args){
String s = "LEGO";//String变量s有indexOf方法
int s1 = s.indexOf('l');//传入字符
int s2 = s.indexOf("LL");//传入字符串
int s3 = s.indexOf("LL", 2);//传入字符串，指定从哪个位置开始搜索
}
}3 . String类的方法重载indexOf
（1）int indexOf(int ch)
（2）int indexOf(String str)
（3）int indexOf(int ch, int fromIndex)
（4）int indexOf(String str, int fromIndex)
String s = "Hello,World!";
s.indexOf('o');//4
s.iodexOf("11");//2
s.indexOf('o', 6);//8
s.indexOf("11", 6);//-1下面是一个例子：
首先我们定义一个Person类，如果用户传入一个String参数，
public class Person {
private String name;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
//如果用户传入一个String参数，就将参数赋值给字段name
}
public void setName(String firstName, String lastName) {
this.name = firstName + " " + lastName;
//如果用户传入两个String参数，将参数分分别传入firstName和lastName，并在中间添加空格连接
}
}之后编写main方法
public class Main {
public static void main(String[] args) {
Person ming = new Person();
ming.setName("小明");
System.out.println(ming.getName());//小明
//当传入一个参数"小明"时，调用的是第一个setName方法
Person hong = new Person();
hong.setName("Xiao", "Hong");
System.out.println(hong.getName());//Xiao Hong
//当传入两个参数"Xiao"和"Hong"时，调用的是第二个setName方法
}
}
注意：在方法重载过程中不要交换参数顺序
三、继承和多态
（一）继承
1 . 什么是继承
继承是一种代码的复用方式
如果我们已经创建了一个Person类：
public class Person {
private String name;
private int age;
public void run(){
}
}然后继续编写一个拥有Person类相同方法的Student类时，可以有两种办法实现
第一个方法：我们将Person类方法的代码复制到Student类中，然后再添加新增的代码
public class Student {
private String name;//复制的代码
private int age;//复制的代码
public void run(){//复制的代码
}
private int score;//新增的代码
public void setScore(int score){//新增的代码
}
public int getScore;//新增的代码
}可以发现Student类中包含了Person类中已有的方法和代码，如果需要编写大量的相同方法时就会变得繁琐，工作量也特别大。
所以我们还可以使用第二种方法，也就是继承（extends）来实现这个功能：
public class Student extends Person {//使用extends关键字将Person的全部功能继承下来
private int score;//新增的代码
public void setScore(int score){//新增的代码
}
public int getScore;//新增的代码
}1.Student获得Person的所有功能
2.继承使用关键字extends
3.Student包含Person已有的字段和方法
4.Student只需编写新的功能
2 . 继承树
在上面的例子中
（1）Person类称为超类（super）、父类或者基类
（2）Student类称为子类（subclass）或扩展类
可以注意到，在编写Person类的代码时，我们并没有编写extends继承关系。如果我们在编写类的代码时没有使用extends关键字，编译器将会自动从Object类继承。Object是Java提供的所有类的根类。
所以我们可以理解，Student继承自Person，而Person继承自Object，这样便形成了继承树的关系。
我们可以用生物学的概念将其理解为：狮子和老虎都属于猫科动物，而猫科动物都属于动物的子类，狮子和老虎都是猫科动物的子类，而猫科动物则是动物的一个子类。
（3）Java规定一个class只能继承自一个类
（4）一个类有且仅有一个父类（Object除外）
下面我们编写一个完整的方法功能继承代码：
首先编写Person类的代码：
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void run() {
System.out.println(name + " is running!");
}
}
然后编写Student类的代码将Person类的功能继承下来：
public class Student extends Person {//使用extends关键字将Person的全部功能继承下来
private int score;//新增的代码
public void setScore(int score){//新增的代码
}
public int getScore;//新增的代码
}最后编写main方法：
public class Main {
public static void main(String[] args) {
Person p = new Person();//创建一个Person类的实例
Student s = new Student();//创建一个Student类的实例
p.setName("Zero");//设置实例的名称
s.setName("One");//设置实例的名称
run.p();//对变量p执行run()方法
run.s();//对变量s执行run()方法
}
}在执行上面的代码后我们发现，run()方法的定义在Person内部，我们通过让Student类继承Person类，让Student类也可以直接调用run()方法，从而省去了大量的重复代码。
3 . 继承访问权限（protected字段）
我们来看一段代码：
public class Person {
private String name;
private int age;
public void run(){
}
public class Student extends Person {
public String hello(){
return "Hello," + this.name;//编译错误上面这段代码运行后，编译器会产生编译错误，这是因为Java规定：
（1）Person定义的private字段无法被子类访问
（2）用protected修饰的字段可以被子类访问
我们将上面这段代码进行修改：
public class Person {
protected String name;//将private修改为protected
private int age;
public void run(){
}
public class Student extends Person {
public String hello(){
return "Hello," + this.name;这样Student类便可直接访问Person类中的字段和方法，可见，protected把字段和方法的访问权限控制在继承树内部。
4 . 继承关系中的构造方法
（1）在我们编写Person类的时候，可以创建一个构造方法，或者或者由编译器自动为我们创建默认的构造方法
（2）在子类中，由于子类包含父类拥有的所有功能，所以子类必须手动调用父类的构造方法
（3）Java规定，子类的构造方法的第一行语句，必须调用父类的构造方法：super()
①super()关键字代表父类（超类）
②没有super()时编译器会自动生成super()
public class Person {
public Person(){
System.out.println("create Person");
}
}
public class Student extends Person {
public String(){
super();//调用父类构造方法
System.out.println("create Student");
}
}③如果父类没有默认构造方法，子类就必须显式调用super()
public class Person {
public Person(String name){//Person类没有使用默认构造方法
System.out.println("create Person");
}
}
public class Student extends Person {
public String(){
super();//继续使用super()编译器将会报错
System.out.println("create Student");
}
}public class Person {
public Person(String name){
System.out.println("create Person");
}
}
public class Student extends Person {
public Student(String name){//传入参数
super(name);//显式调用父类的构造方法
System.out.println("create Student");
}
}④在显式调用父类的构造方法后，main方法中的代码格式也需要进行修改
public class Main {
public static void main(String[] args) {
Person p = new Person("Zero");
Student s = new Student("One");
p.run();
s.run();
System.out.println(s.Hello());
}
}5 . 向上转型upcasting()
（1）当我们定义一个类的时候，实际上是定义了一种数据类型。在我们定义继承的时候，相当于在这些类型之间增加了继承的关系。
（2）在我们创建一个实例对象时，需要将它赋值给一个引用类型的变量，让变量指向实例对象。
（3）在这里产生了向上转型upcasting()的概念：实例变量可以进行向上转型
Person p = new Person();
Student s = new Student();
Person ps = new Student();
//把一个子类安全的转型为父类的过程称为向上转型
Object o1 = p;
Object o2 = s;
为什么面向对象编程中允许实例变量进行向上转型？
假如我们持有一个对象Student实例，那么我们可以保证，Student实例包含Person的全部功能，因此我们将其视为一个Person类型的变量。向上转型把一个子类型安全的变为更加抽象的类型
6 . 向下转型downcasting()
与向上转型原理类似，向下转型允许我们将一个父类类型强制转换为一个子类类型
（1）Java可以对实例变量进行向下转型
（2）向下转型把一个抽象的类型转变成一个具体的子类型
（3）向下转型很可能会报错：
Person p = new Person();
//在这里变量p有可能是Person类型也有可能是Student类型
Student s = (Student) p;//ClassCastException 如果变量p指向的实际类型并不是Student实例，JVM在运行时会抛出ClassCastException
（4）instanceof操作符可以判断对象的实际类型
①为了判断对象的实际类型，JVM提供了instanceof操作符
Person p = new Person();
System.out.println(p instanceof Person); // true
System.out.println(p instanceof Student); // false②在使用instanceof判断对象的类型时，其判断的是是否是某个类型或者是某个类型的子类
Student s = new Student();
System.out.println(s instanceof Person); // true
System.out.println(s instanceof Student); // true③如果一个引用变量的值是null，对于任何instanceof判断的结果都是false
Student s = new Student();
System.out.println(s instanceof Person); // true
System.out.println(s instanceof Student); // true所以我们在做向下转型之前，首先用instanceof进行判断再进行向下转型
Person p = new Student();
if(p instanceof Student){
Student s = (Student) p;//OK
}7 . 区分继承与组合的区别
public class Person {
private String name;
private int age;
public void run(){
}
}
public class Book {
private String name;
}
public class Student extends Book {
private int score;
public int getScore(){
}
}在上面这段代码中，定义了Person、Student、Book类，分别代表人、学生和书。我们可以看出Student类并不应该从Book类继承，因为在现实世界中，Student与Book并不是继承的关系。
所以我们将上面的代码进行修改：
public class Person {
private String name;
private int age;
public void run(){
}
}
public class Book {
private String name;
}
public class Student extends Person {
private Book book;//在Student类中声明一个Book实例
private int score;
public int getScore(){
}
}所以我们可以理解为：
（1）继承是是或不是的区别
（2）组合是有和没有的区别
（二）多态
1 . 方法的覆写Override
（1）子类重写父类的方法称作覆写
public class Person(){
public void run(){
}
}
public class Student extends Person {
@override
public void run(){//覆写方法的参数和返回值相同，方法的语句不同
}
}（2）方法签名如果不同就不是Override，而是创建了一个新方法
public class Person(){
public void run(){
}
}
public class Student extends Person {
public void run(String s){//创建一个新方法
}
}（3）添加@Override可以让编译器帮助检查是否进行了正确的覆写（@Override不是必须的）
public class Person(){
public void run(){
}
}
public class Student extends Person {
@override//Compile error！ 让编译器检查是否进行了正确的覆写
public void run(String s){//创建一个新方法
}
}在之前我们了解到，引用变量的声明类型可能与实际类型不符，例如：
public class Person(){
public void run(){
}
}
public class Student extends Person {
@override
public void run(){
}
Person p = new Student();
p.run();//这里调用的是Person还是Student的run()方法呢？
}2 . 动态调用
（1）实例对象的方法调用总是对应实际类型
（2）Java的实例方法调用是基于运行时实际类型的动态调用
public class Person(){
public void run(){
}
}
public class Student extends Person {
@override
public void run(){
}
Person p = new Student();
p.run();//这里调用的是Student的run()方法
}3 . 多态的意义
（1）多态是指针对某个类型的方法调用，其真正执行的方法取决于运行时其实际类型的方法
（2）对某个类型调用某个方法，执行的方法可能是某个子类的覆写方法
（3）利用多态，允许添加更多类型的子类实现功能扩展
4 . Object定义的重要方法
（1）toString：把instance输出为String
（2）equals：判断两个instance是否逻辑相等
（3）hashCode：计算一个instance的哈希值
public class Person {
...
@Override
public String toString(){//把实例instance输出位String类型
}
@Override
public boolean equals(Object o){//判断两个实例是否逻辑相等
}
@Override
public int hashCode(){//计算实例的哈希值
}
}5 . super关键字
当我们在一个子类的覆写方法中，想要调用父类被覆写的方法时，可以使用super关键字，允许我们调用父类的同名方法
public class Person {
private String name;
public String hello() {
return "Hello," + name;
}
}
public class Student extends Person {
@Override
public String hello() {
return super.hello() + "!";//调用父类的hello()方法
}
}6 . final关键字
当我们定义一个类时，如果我们不希望某个方法被子类覆写，可以在方法前面添加final修饰符
（1）用final修饰的方法不能被Override
（2）用final修饰的类不能被继承
（3）用final修饰的字段在初始化后不能被修改
public class Person {
public final void setName(String name) {//方法不能够被子类覆写
}
}
public final class Student extends Person {//class不能够被继承
private final int scroe;//字段初始化后不可修改
}四、抽象类和接口
（一）抽象类
1 . 抽象类的概念
在前面我们已经学过，每一个子类都可以覆写父类的方法，如果父类的方法并没有实际意义，我们能否去掉执行语句呢？
例如：
public class Person {
public void run();
}
public class Student extends Person {
@Override
public void run(){
}
}
public class Teacher extends Person {
@Override
public void run(){
}
}如果我们将Person类的run()方法的执行语句去掉，会发生编译错误
如果我们通过注释的方式去掉run()方法，同时也会失去父类的多态特性
那么在这种情况下，我们可以使用抽象方法，也就是定义抽象类
我们可以使用abstract关键字声明父类的方法为抽象方法：
public abstract class Person {//定义了抽象方法的类是抽象类
public abstract void run();//定义抽象方法，没有任何执行语句
public class Student extends Person {
@Override
public void run(){
}
}
public class Teacher extends Person {
@Override
public void run(){
}
}（1）如果一个class定义了方法，但没有具体的执行代码，这个方法就是抽象方法
（2）抽象方法用abstract修饰
（3）抽象方法没有任何执行语句
（4）定义了抽象方法的类就是抽象类（abstract class）
（5）无法实例化一个抽象
public abstract class Person {
public abstract void run();
}
Person p = new Person();//编译错误，因为抽象类不可以实例化
Person s = new Student();//可以实例化子类
Person t = new Teacher();//可以实例化子类
s.run();//调用抽象方法实现多态
t.run();//调用抽象方法实现多态2 . 抽象类的作用
那么无法实例化的抽象类有什么作用呢？
（1）抽象类用于被继承
（2）从抽象类继承的子类必须实现其抽象方法
（3）抽象方法实际上相当于定义了子类必须实现的接口规范
（4）如果子类没有实现抽象方法，这个子类依然是一个抽象类
public class abstract Person {
public abstract void run();
}
public class Student extends Person {
@Override
public void run();
}
public class Teacher extends Person {
@Override
public void run();
}3 . 面向抽象编程的本质：
Person s = new Student();
Person t = new Teacher();
//不需要关心Person类型对象的具体类型
s.run();
t.run();（1）上层代码只编译规范
（2）不需要子类就可以实现业务逻辑
（3）具体的业务逻辑由不同的子类实现，调用者无需关心
下面是一个具体的例子：
首先创建Shape类，表示图形，定义一个area()方法为抽象方法
public abstract class Shape {
public abstract double area();
}然后创建ShapeUtil类，编写一些图形计算的业务代码：
public class ShapeUtil {
public double sum(Shape[] shapes) {//面积求和
double s = 0;
for (Shape shape : shapes) {
s += shape.area();
}
return s;
}
public boolean isGreaterThan(Shape shape1, Shape shape2) {
return shape1.area() > shape2.area();//比较面积大小
}
public boolean isLessThan(Shape shape1, Shape shape2) {
return shape1.area() < shape2.area();//比较面积大小
}
}可以看到，我们定义了抽象类，并没有实际的执行代码，但是不影响编写业务代码
然后我们从Shape中继承第一个子类长方形Rect：
public class Rect extends Shape{//从Shape继承
private final double width;
private final double height;
public Rect(double width, double height){//初始化Rect
this.width = width;
this.height = height;
}
@Override
public double area(){
return width * height;
}
}然后定义Shape的第二个子类圆形Circle：
public class Circle extends Shape{
private final double radius;
public Circle(double radius){
this.radius = radius;
}
@Override
public double area(){
return Math.PI * radius * radius;
}
}最后进行Main方法的编写：
public class Main {
public static void main(String[] args) {
Shape s1 = new Rect(200, 100);
Shape s2 = new Circle(60);
System.out.println(s1.area());
System.out.println(s2.area());
}
}在Main方法中我们可以看到，我们引用了Shape类型的抽象类，而area()方法调用的实际上是其子类的方法。在这里程序只关心子类是否包含area()方法，而不关心子类如何去实现area()方法
如果我们不使用抽象类方法去扩展子类的功能会是什么样子呢？
public class BadShape {//这里举出反例
private String type;//使用一个type类型表示不同类型的Shape
private double width;
private double height;
private double radius;
//然后利用switch语句根据Shape的不同type类型进行计算
public double area() {
switch (type) {
case "Rect":
return width * height;
case "Circle":
return Math.PI * radius * radius;
default:
return 0;
}
//当Shape的种类逐渐增加时，我们需要不断的区修改switch语句的代码
//每增加一种Shape类型，就需要对这段代码进行修改
}
}如果我们使用了抽象类，我们可以不对抽象的类的代码做任何修改，也不需要对Main方法进行修改。通过添加子类继承的方式，不断的增加我们需要的功能。
（二）接口
1 . 接口的概念
在抽象类的概念中我们知道，抽象方法的本质是定义接口规范。如果一个抽象类没有字段，所有方法都是抽象方法，就可以将该抽象类改写为接口interface
（1）在Java中我们使用interface声明一个接口
（2）接口定义的方法默认是public abstract
public interface Person {//使用interface声明一个接口
void run();//定义的方法默认为public abstract，所以不需要手动编写
}2 . Java内置的纯抽象接口
（1）interface是Java中内置的纯抽象接口
（2）实现interface使用implements
（3）可以实现多个interface
（4）接口也是数据类型，可以进行向上转型和向下转型
（5）接口不能定义实例字段
public interface Hello {//定义一个Hello接口
String hello();
String goodbye();
}
public class Person implements Hello {//实现Hello接口
}
public class Robot implements Hello, Comparable {//实现Hello接口
}
3 . 注意区分术语
（1）Java的接口特指interface定义的接口,只定义方法签名
（2）编程接口泛指接口规范，如方法签名、数据格式、网络协议等等
4 . 抽象类与接口的区别
（1）在继承关系中，一个子类只能继承一个抽象类。而在接口中，可以implenments多个interface
（2）对于字段，在抽象类中，我们可以定义实例字段。但在接口中我们不能定义实例字段
（3）对于抽象方法，在abstract class和interface中我们都可以定义抽象方法
（4）对于非抽象方法，在abstract class中可以定义非抽象方法，也就是实例方法。在interface中，我们只能定义default方法。
继续引用在抽象类中的例子：
首先，定义接口Shape：
public interface Shape {//这里定义接口
double area();
}然后，编写需要实现Shape的子类Rect：
public class Rect implements Shape {//由abstract变为implements
private final double width;
private final double height;
public Rect(double width, double height) {
this.width = width;
this.height = height;
}
@Override
public double area() {
return width * height;
}
}然后，编写需要实现Shape的子类Circle：
public class Circle implements Shape {//由abstract变为implements
private final double radius;
public Circle(double radius) {
this.radius = radius;
}
@Override
public double area() {
return Math.PI * radius * radius;
}
}然后，定义Main方法：
public class Main {
public static void main(String[] args) {
Shape s1 = new Rect(200, 100);
Shape s2 = new Circle(80);
System.out.println(s1.area());
System.out.println(s2.area());
}
}在上面这段代码中，我们发现使用interface和过去使用abstract的结果并没有区别。如果我们给Shape接口增加一个新的方法，例如：
public interface Shape {//这里定义接口
double area();
double perimeter();//新增计算周长的方法
}这时我们会发现所有的子类都会发生编译错误，因为子类目前还没有实现这个新增的方法接口。如果我们不希望在每一个子类中都去实现这个抽象方法，我们可以在接口中将这个方法定义为default方法：
public interface Shape {//这里定义接口
double area();
default double perimeter(){
return 0;//在default方法中，设置方法的返回值为0
}
}定义default方法后，所有的子类都不必实现这个方法同时实现Shape接口。
任何子类也可以覆写这个default方法来实现自己的逻辑
5 . interface的继承
（1）一个Interface可以继承自另一个interface
（2）interface继承自interface使用extends关键字
public interface Person {
String getName();
}
public interface Student extends Person {
//定义Student类型的接口扩展到Person类型的接口
String getSchool();//新增一个方法
}
public class PrimaryStudent implements Student {
@Override
public String getName(){
}
@Override
public String getSchool(){
}
}
（3）interface继承相当于扩展了接口的方法
上面的例子中，PrimaryStudent必须实现Student中定义的方法和Person中定义的方法
（4）需要合理设计继承关系
①合理设计interface和abstract class的继承关系
②公共逻辑需要放在abstract class中
③接口层次代表了抽象的程度
List list = new ArraysList();
Collection coll = list;
Iterable it = coll;当我们通过List接口来引用一个ArraysList实例的时候，我们可以调用abstractList定义的所有方法。当我们把List接口向上转型至Collection接口时，我们就只能用abstractCollection定义的所有方法。最后我们把Collection接口向上转型为Iterable接口，我们就只能用abstractIterable定义的方法。
五、包和classpath
（一）静态字段和方法
1 . 静态字段
用static修饰的字段称为静态字段
（1）普通字段在每个实例中都有自己独立的空间
（2）静态字段只有一个共享空间，所有的实例都共享该字段
public class Person {
public String name;
public int age;
public static int number = 100;
}
对于Person类中的所有实例，都共享Person类的Number字段
public class Person {
public String name;
public int age;
public static int number = 100;
Person ming = new Person();
Person hong = new Person();
//可以通过 实例字段.静态变量名 来访问这个静态字段，但是不推荐这样做
ming.number = 99;//warning!
System.out.println(hong.number);//99
//可以通过类名来访问静态字段
Person.number = 88;
System.out.println(Person.number);//88
}因为在Java程序中，实例对象并没有静态字段。在代码中，实例对象能够访问静态字段，只是因为编译器根据类型实例自动转化成类名来访问静态字段。
（3）我们可以把静态字段理解为：描述class本身的字段（非实例字段）
2 . 静态方法
（1）静态方法的概念
用static修饰的方法称为静态方法
①调用实例方法必须通过实例变量
②调用静态方法不需要通过实例变量
③静态方法类似于其他编程语言中的函数
public class Person {
private String name;
private static int number = 100;
public static void setNumber(int num) {
number = num;
}
}
Person.setNumber(999);
（2）静态方法的限制
①静态方法不能访问this变量
②静态方法不可以访问实例字段
③静态方法可以访问静态字段
（3）静态方法的用途
①静态方法经常用于工具类
——Arrays.sort()
——Math.roandom()
②静态方法经常用于辅助方法
③Java程序的入口Main()也是静态方法
下面是一个例子：
创建一个Person类，计算一共创建了多少个Person对象：
public class Person {
private static int number;//定义静态字段number
private String name;
public Person(String name) {
this.name = name;
number++;//每次调用构造方法，number+1
}
public String getName() {//定义静态方法用来获取number
return this.name;
}
public static int getNumber() {
return number;
}
}
在Main方法中创建3个Person类的实例，每创建一个实例后，打印出Person的getNumber()静态方法返回的值
public class Main {
public static void main(String[] args) {
Person p1 = new Person("小明");
System.out.println(Person.getNumber());//1
Person p2 = new Person("小红");
System.out.println(Person.getNumber());//2
Person p3 = new Person("小军");
System.out.println(Person.getNumber());//3
}
}可以看到，每创建一个实例，静态变量number就会+1
（二）包package
1 . package的概念
（1）解决Java编程中出现的类名冲突问题
假设：
明日香写了一个Person.Java
绫波丽写了一个Person.Java
淀真嗣写了一个Arrays.Java
JDK自带了一个Arrays.Java
可以看出，两个Person和两个Arrays的类名势必会引起冲突
在Java中，我们使用package机制来解决类名冲突问题
（2）Java定义了名字空间：包（package）的概念
（3）包名 + 类名 = 完整类名
所以，通过package机制，可以将上面的包名规定为下面的完整包名：
①明日香的Person类：Asuka.Person
②绫波丽的Person类：Rei.Person
③淀真嗣的Arrays类：Shinji.Arrays
④JDK的Arrays类：java.util.Arrays
（4）JVM只看完整类名，包名不同，类就不同
①包可以是一个多层结构，例如：java.util.Arrays
②包没有父子继承关系，例如java.util与java.util.zip是两个不同的包
③JVM在加载class并执行代码时，总是使用class的完整类名
④编译器编译后的class文件中全部是完整类名
2 . 包作用域
（1）位于同一个包的类，可以访问包作用域的字段和方法
（2）不使用public、private、protected、修饰的字段和方法就是包作用域
3 . 引用其他类
（1）使用完整类名
例如:java.util.Arrays.sort(ns)
package Hello;
public class World {
public int findMin(int[] ns) {
java.util.Arrays.sort(ns);
return ns[0];
}
}（2）先使用import再使用类名
例如：import java.util.Arrays
package Hello;
import java.util.Arrays();//先使用import声明
public class World {
public int findMin(int[] ns) {
Arrays.sort(ns);//在这里使用简单的类名
return ns[0];
}
}（3）在import语句中，我们可以使用通配符 * ：
例如：import java.util.*
这时，会把util下面所有的包都加载进来，所以并不推荐这种写法
（4）静态导入
①import static可以导入一个类的静态字段和静态方法
②import static java.util.system.*
import static java.lang.system.*;
public class Main {
public static void main(String[] args) {
//System.out.println(...);
out.println("Hello,World!");
//由于out是System方法的静态字段，因此可以将System.out改写为out
}
}
③import static这种方法很少使用
4 . 查找class
编译器最终编译出的.class文件类名只使用完整类名，因此，在代码中，编译器在遇到一个class名称时：
（1）如果是完整类名：直接根据完整类名查找
java.util.List list;//java.util.List（2）如果是简单类名：
①查找当前package的class
②查找import的class
③查找java.long包的class
import java.text.Format;
java.util.List list;//java.util.List
Format format = null;//java.text.Format
String s = "hi";//java.lang.String
System.out.println(s);//java.lang.System
（3）如果无法确定类名：编译器将会报错
（4）自动import：
在编写class时：
①默认自动import当前package的其他class
②默认自动import java.long.*
package com.feiyangedu;
import.com.feiyangedu.*;//由于是编译器默认，所以不需要写出
import java.long.*;//由于是编译器默认，所以不需要写出
5 . java源文件
（1）Java源文件要按照package的层次按目录存放
①class:com.feiyangedu.sample.Hello
②src(源代码根目录)→com→feiyangedu→sample→Hello.java
（2）编译后的class文件也要按照package的层次目录存放
①class:com.feiyangedu.sample.Hello
②bin(编译输出的根目录)→com→feiyangedu→sample→Hello.class
6 . 最佳实战
（1）包名使用倒置的域名可以确保唯一性：例如org.apache.commons.log
（2）不要和java.long包的类重名：例如String,System,Runtime等
（3）不要和JDK常用名重名：例如java.util.list、java.util.Format等
（三）作用域
1 . 访问权限
（1）访问权限的概念：
Java的类、接口、字段和方法都可以设置访问权限
①访问权限是指在一个类的内部，能否引用另一个类的字段和方法
②访问权限有public、protected、private、package四种
（2）public
package abc;
public class Hello {
public void hi(){
}
}
package xyz;
class Main {
void foo{
//Main可以访问Hello
Hello h = new Hello();
}
}①定义为public的class和interface可以被其他类访问
②定义为public的field和method可以被其他类访问
（3）private
package abc;
public class Hello {
public void hi(){
this.hi();
}
}
private void hi();①定义为private的field和method无法被其他类访问
②private权限限定在class内部，与方法的声明顺序无关
③定义在一个class内部的class称为内部类(inner class)
（4）protected
package abc;
public class Hello {
protected void hi(){
}
}
package xyz;
class Main extends Hello {
void foo{
Hello h = new Hello();
h.hi();
}
}①protected作用于继承关系中
②定义为protected的字段和方法可以被子类访问
（5）package
package abc;
class Hello {
void hi(){
}
}
package xyz;
class Main {
void foo{
Hello h = new Hello();
h.hi();
}
}①位于同一个包的类，可以访问包作用域的字段和方法
②没有public、private修饰的class
③没有public、private、protected修饰的字段和方法
④包名必须完全一致
⑤如果不确定是否需要public，就不声明为public，尽可能少地减少暴露对露方法
2 . 局部变量
（1）在方法内部定义的变量被称为局部变量
（2）局部变量的作用域是从声明变量处开始到对应的块结束处（也就是一组花括号对应的开始于结束位置）
（3）尽可能的将局部变量的作用域缩小
（4）尽可能延后声明局部变量
package abc;
public class Hello {
void hi(String name) {
String s = name.toLowerCase();
int len = s.length();
if(len < 10) {
int p = 10 - len;
for(int i - 0, i < 10, i++){
System.out.println();
}
}
}
}
一个Java文件中只能存在一个public class，但是可以存在多个非public class：
package com.feiyangedu.sample;
import static java.lang.System.out;
public class Main {//只能定义一个public class
public static void main(String[] args) {
Hello h = new Hello("World");
out.println(h.hello());
}
}
class Hello {//可以定义多个非public class
private final String name;
public Hello(String name) {
this.name = name;
}
public String hello() {
return "Hello, " + name + "!";
}
}3 . final关键字
（1）final与访问权限不冲突
（2）用final修饰class可以阻止被继承
（3）用final修饰method可以阻止被覆写
（4）用final修饰field可以阻止被重新赋值
（5）用final修饰局部变量可以阻止被重新赋值
package abc;//与访问权限不冲突
public final class Hello {//阻止class被继承
private final int n = 0;//阻止field被重新赋值
protected final void hi(int t){//阻止method被覆写
final long i = t;//阻止局部变量被重新赋值
}
}（四）classpath和jar
1 . classpath
（1）classpath的概念
①classpath是一个环境变量
②classpath指示JVM如何搜索class
③classpath设置的搜索路径与操作系统有关：
——Windows系统：
C:\work\project1\bin;C:\shared;”D:\My Document\project2\bin”（如果目录含有空格，必须用双引号括起来）
——Mac OS X系统：
/usr/shared/:/usr/local/bin:/home/feiyangedu/bin
我们假设classpath的目录是.;C:\work\project1\bin;C:\shared
JVM在加载com.feiyangedu.Hello这个类时，依次查找：
——<当前目录>\com\feiyangedu\Hello.class
——C:\work\project1\com\feiyangedu\Hello.class
——C:\shared\com\feiyangedu\Hello.class
如果在某个路径下找到，将不再继续搜索
如果没有找到，编译器将会报错
（2）classpath的设置方法
①直接在系统环境中设置classpath环境变量（不推荐，因为在系统环境中设置的classpath会干扰到特定的程序）
②在启动JVM时设置classpath环境变量（推荐）
在启动JVM时，可以传入：
——java -classpath C:\work\bin;C:\shared com.feiyangedu.Hello
——java -cp C:\work\bin;C:\shared com.feiyangedu.Hello（简化的参数）
③没有设置环境变量，也没有设置-cp参数，默认的classpath为 . ，即当前目录
④在Eclipse中运行Java程序，Eclipse自动传入的-cp参数是当前工程的bin目录和引入的jar
2 . jar
（1）什么是jar包
①jar包是zip格式的压缩文件，包含若干.class文件
②jar包相当于目录
③classpath可以包含jar文件：C:\work\bin\all.jar
④查找com.feiyangedu.Hello类将在C:\work\bin\all.jar文件中搜索com\feiyangedu\Hello.class
⑤使用jar包可以避免大量的目录和class文件
（2）如何创建jar包
如果我们创建了大量的class文件，如何打包到jar包中呢？
①使用JDK自带的jar命令
②使用构建工具如Maven等
③由于jar包与zip格式是相同的，我们可以直接使用相关的zip软件来创建jar包
（3）jar包的其他功能
①jar包可以包含一个特殊的/META-IF/MAINIFEST.MF文件
②MAINIFEST.MF是纯文本，可以指定Main-Class和其他信息
③jar包可以包含其他jar包
（4）JDK自带的class
①JVM运行时会自动加载JDK自带的class
②JDK自带的class被打包在rt.jar中
③不需要在classpath中引用rt.jar
六、Java核心类
（一）字符串和编码
1 . 字符串
（1）String的特点
Java中的字符串用String表示，其特点有两个：
1.可以直接使用”…”调用
2.String的内容一旦创建不可变更
String s1 = "Hello";//使用"..."调用
String s2 = new String("World");//内容一旦创建不可变更（2）字符串常用操作
比较String的内容：
1.equals(Object)方法（String覆写Object的方法）
2.equalsIgnoreCase(String) （忽略String内容的大小写来进行比较）
String s ="hello";
s.equals("Hello");//false
s.equalsIgnoreCase("Hello");//true在String查找是否存在子串
1.返回是否存在某个子串：booleans contains(CharSequence)
2.返回子串的索引位置：
int indexOf(String)，如果没有找到，返回值为 -1
int lastindexOf(String)，从末尾开始查找
3.返回字符串由哪里开始：boolean startsWith(String)
4.返回字符串由哪里结束：boolean endWith(String)
String s = "hello";//是否存在某个子串
s.contains("ll");//是否存在某个子串：true
s.indexOf("ll");//ture子串的索引位置：2
s.startsWith("he");//字符串是否由这里开始:true
s.endWith("lo");//字符串是否由这里结束:true移除首尾空白字符
String提供了一个trim()方法用来移除首位空白字符
空白字符包括：空格，\r，\t，\n
String s = " \t hello\r\n";
String s2 = s.trim();//"hello"
s = s.trim();注意：trim()不改变字符串内容，而是返回新的字符串
提取子串
在Java中使用substring()方法来提取字符串的子串
String s = "Hello,World";
s.substring(7);//"World"
s.sunstring(1,5);//"ello"注意：substring()并不改变字符串的内容，而是返回新字符串
大小写切换
1.大写切换：toUpperCase()
2.小写切换：toLowerCase()
String s = "hello";
s.toUpperCase() = "HELLO";
s.toLowerCase() = "hello";替换子串
1.替换一个字符：replace(char,char)
2.替换一串字符：replace(CharSequence,CharSequence)
String s = "hello";
s.replace('l', 'w'); = "hewwo";
s.replace("l", "w~"); = "hew~w~o";3.用正则表达式替换子串：replaceAll(String,String)
String s = "A, ,B; C, D";
s.replaceAll("[\\,\\;\\s)]+", ", ");//"A, B, C, D"这个方法的功能要比replace()更加强大，之后我们会学习到正则表达式的用法
分割字符串：String[] split(String)
String s = "A,,B;C,D";
String[] ss = s.split("[\\,\\;\\s]+");//"A","B","C","D"拼接字符串：static String join()
String[] arr = {"A", "B", "C"};
String s = String.join("~~", arr);//"A~~B~~C"（3）字符串的类型转换
把任意数据转换为String
1.转换为整型：static String valueOf(int)
2.转换为布尔类型：static String valueOf(boolean)
3.转换为Object类型：static String valueOf(Object)
String valueOf(123);//123
String valueOf(true);//"true"
String valueOf(new Object());//"[email protected]"注意：对于Object类型，还可以使用toString()方法转换字符串
把String转换为其他类型
1.static int Integer.parseInt(String)
2.static Integer Integer.valueOf(String)
int i = Integer.parseInt("123");//123
Integer I = Integer.valueOf("123");String与char[]的相互转换
1.String转换为char[]：char[] toCharArray()
2.char[]转换为String：new String(char[])
String s = "hello";
char[] cs = s.toCharArray();//{'h','e','l','l','o'}
String s2 = new String(cs);注意：String是不可变类型，当我们调用toCharArray()时，字符串内部实际上是复制了一份char[]，如果我们修改返回后的char[]，不会影响到原来String中的内容
String与byte[]的相互转换
如果将String与byte[]进行转换，会涉及到编码
1.String转换为byte[]
①byte[] getBytes()（不推荐）
这个方法使用操作系统默认的编码格式，但是并不推荐这样做。因为在Windows系统上，系统默认的编码格式是GBK格式，而在Linux和Mac OS X系统上，系统的默认编码是UTF-8格式
②byte[] getBytes(String)
③byte[] getBytes(Charset)
String s = "hello";
byte[] bs1 = s.getBytes("UTF-8");
byte[] bs2 = s.getBytes(StandardCharsets.UTF-8);
//可以得到使用UTF-8编码的byte[]2.byte[]转换为String
①new String(byte[],String)
②new String(byte[],Charset)
String s = "hello";
new String(bs1, "UTF-8");
new String(bs2, StandardCharsets.UTF-8);2 . 编码
（1）编码的概念
由于计算机只能识别数字，如果我们希望表示字符，实际上是将字符转换为数字的形式传输给计算机识别。
1.ASCII编码
①ASCII编码是最早的计算机字符编码
②一个字符占用1个字节
③第一个字节最高位是0，最多表示128个字符
例如：字符’A’ = 0x41（具体字符编码请自行参照《ACSII编码规则》）
2.中文编码
①由于ASCII编码最多只能表示128个字符，对于中文字符显然是不够的，因此一个中文字符占用2个字符
②中文编码规范目前共有三种：GB2132、GBK、GB18030
③第一个字节最高位是1
例如：’中’ = d6d0（GBK）
3.其他编码：
①日文编码：Shift_JIS编码
②韩文编码：Euc-kr编码
（2）Unicode编码
不同的国家使用相同的2字节进行编码时，如果我们在同一个网页中即显示中文编码又显示日文或韩文编码，就可能产生编码冲突，从而产生乱码。为了解决各个国家编码不一致的情况，出现了Unicode全球统一编码格式
①Unicode是全球统一编码
②全球所有文字都拥有唯一编码
③一个Unicode字符通常占用2个字节
UTF-8编码
由于英文Unicode编码与ACSII编码不一致，包含大量英文文本会浪费空间，所以衍生出了UTF-8编码。
UTF-8编码是一种变长编码：
①英文UTF-8编码与ACSII编码一致
②其他Unicode编码需占用2-6个字节不等
③UTF-8编码容错能力更强
编码的最佳实践
①Java使用Unicode编码
②Java程序运行时使用Unicode编码
③输入输出时把String和byte[]转换，需要考虑编码
④编程时始终优先考虑UTF-8编码
（二）StringBuilder
我们在编写程序时，经常需要拼接字符串。字符串可以直接使用 + 来拼接，但是有些时候，如果我们在循环中去拼接字符串，每次循环都会创建新的字符串对象，这些字符串对象绝大多数都是临时对象，浪费内存空间，影响GC效率
String s = "";
for(int i = 0, 1 < 1000, i++){
s = s + String.valueOf(i);
}1 . 用StringBuilder高效拼接字符串
对于这种大量且零碎的字符串的拼接，Java提供了StringBuilder类，可以高效的进行字符串拼接。由于StringBuilder是可变对象，所以StringBuilder可以预分配缓冲区，可以把新的字符串不断的放进StringBuilder的缓冲区中，最终得到拼接后的字符串
StringBuilder sb = new StringBuilder(1024);
for(int i = 0, 1 < 1000, i++){
sp.append(String.valueOf(i);
}
String s = sb.toString();2 . StringBuilder可以进行链式操作
StringBuilder sb = new StringBuilder(1024);
String s = sb.append("Mr ")
.append(name)
.append("!")
.insert(0, "Hello,")
.tuString();//让StringBuilder对象返回一个String对象注意：在编程时不需要特别改写字符串 + 操作，编译器在内部自动将连续的多个 + 操作优化为StringBuilder操作
package com.feiyangedu.sample;
public class Main {
public static void main(String[] args) {
String name = "World";
StringBuilder sb = new StringBuilder();
sb.append("Hello, ").append(name).append('!');
String s = sb.toString();
System.out.println(s);
}
}
实现链式操作的关键是返回实例本身
3 . StringBuffer类
（1）StringBuilder与StringBuffer的接口完全相同
（2）StringBuffer是StringBuilder的线程安全版本
（3）StringBuffer只有在跨线程拼接时才会使用
（三）包装类型wrapper
1 . 包装类型的概念
我们知道Java拥有基本类型和引用类型两种数据类型，基本类型不可以看做是对象，那么我们如何将基本类型视为一个对象（引用类型）呢？
答案是不可以的，但是我们可以换一种方法：我们可以定义一个Integer类包含一个实例字段int，这样就把Integer视为int的包装类型（wrapper）。
包装类型本身是引用类型，只是其内部持有一个基本类型的变量。
例如：
public class Integer {
private int value;
public Integer(int value) {
this.value = value;
}
}
Integer n = null;
Integer n2 = new Integer(99);但是我们并不需要直接去编写包装类型，JDK为每种基本类型都创建了对应的包装类型
2 . JDK创建的包装类型
（1）基本类型：boolean → 包装类型：Boolean
（2）基本类型：byte → 包装类型：Byte
（3）基本类型：short → 包装类型：Short
（4）基本类型：int → 包装类型：Integer
（5）基本类型：long → 包装类型：Long
（6）基本类型：float → 包装类型：Float
（7）基本类型：double → 包装类型：Double
（8）基本类型：char → 包装类型：Character
我们以基本类型int为例：
①如果需要将一个int类型变成它的包装类型Integer，我们可以直接创建一个new Integer()对象，传入基本类型int
Integer = new Integer(99);②如果需要将一个Integer包装类型转化为int类型，需要调用intValue()方法，可以返回基本类型int
int i = n.intValue();3 . int、Integer和String的相互转换
（1）可以使用Integer的静态方法valueOf，用来接收int类型或者String类型，并返回一个Integer包装类型：
int i = 100;
Integer n1 = new Integer(i);
Integer = Integer.valueOf(i);
Integer = Integer.valueOf("100");
（2）Integer intValue()方法可以返回基本类型int
int x1 = n1.intValue();（3）Integer的静态方法paresInt()可以把String对象直接转化为基本类型int
int x2 = Integer.paresInt("100");（4）Integer类型转化为String类型：
String s = n1.toString();（5）特别注意：
Integer类提供的getInteger()方法并不能将String对象转化为Integer对象，这个方法是从系统环境中读取系统变量，得到系统变量对应的Integer的值
Integer prop = Integer.getInteger("cpus");4 . int和Integer之间的自动转型
对于基本类型和其对应的包装类型，编译器可以在int和Integer之间自动转型
（1）自动装箱（auto boxing）：
当我们定义包装类型Integer n = 99时，编译器自动将int类型转化为Integer类型，这个操作过程被称为自动装箱
Integer n = 99;//Integer.valueOf(99)（2）自动拆箱（auto unboxing）：
当我们将Integer类型转化为int类型时，编译器会自动调用Integer的intValue()方法，这个操作过程被称为自动拆箱
int i = n;//n.intValue()（3）注意事项：
①自动装箱和自动拆箱仅仅发生在编译阶段
②自动装箱和自动拆箱操作会影响代码的执行效率
③编译后的class代码是没有自动装箱和自动拆箱的，所以它严格区分基本类型和引用类型
④执行自动拆箱时可能会发生报错：
如果一个Integer类型指向null，那么在进行自动拆箱时就会抛出NullPointException
Integer x = null;
int y = x;
//NullPointException5 . 包装类型定义的静态变量
Boolean t = Boolean.TRUE;
Boolean f = Boolean.FALSE;
int max = Integer.MAX_VALUE;//2147483647
int min = Integer.MIN_VALUE;//-2147483648
int sizeOflang = Long.SIZE;//64(bits)
int bytesOflang = Long.BYTES;//8(bytes)6 . 包装类型的继承
Java的包装类型实际上全部继承自Number这个class，所以我们可以利用向上转型的概念，将任意一种包装类型，先变为Number对象，然后利用Number提供的各种方法将他们变为任意基本类型
Number num = new Integer(999);
byte b = num.byteValue();
int n = num.intValue();
long ln = num.longValue();
float f = num.floatValue();
double d = num.doubleValue();（四）JavaBean
1 . JavaBean的概念
许多class的定义都符合：
（1）若干private实例字段
（2）通过public方法读写实例字段
例如：
public class Person {
private String name;
public int age;
public String getName(){
}
public void setName(String name){
}
public int getAge(){
}
public void setAge(int age){
}
}我们把符合这种命名规范的class称为JavaBean
简单来说就是，当我们定义了一个private Type field时，再通过定义一个get方法和set方法来访问这个field
（1）private Type field
（2）public Type getField()
（3）public void setField(Type value)
2 . boolean字段的读方法
（1）private boolean child
（2）public boolean isChild()
（3）public void setChild(boolean value)
3 . 属性Property
（1）通常把一组对应的getter和setter称为属性(Property)
例如对于name属性：
对应读方法：getName()
对应写方法：setName()
public class Person {
private String name;
public int age;
public String getName(){
}
public void setName(String name){
}
}（2）只有getter的属性称为只读属性(Read-only)
public class Person {
private String name;
public int age;
public String getName(){
}
public void setName(String name){
}
public int getAge(){
}
} （3）只有setter的属性称为只写属性(Write-only)
例如对于age属性：
public class Person {
private String name;
public int age;
public String getName(){
}
public void setName(String name){
}
public void setAge(int age){
}
} （4）属性只需要对应相应的getter/setter方法，不一定需要有对应的字段
4 . JavaBean的作用
（1）方便IDE读写属性
（2）传递数据
（3）枚举属性
可以利用IDE快速生成JavaBean，使用Introspector.getBeanInfo()获取属性列表
（五）枚举类Enumeration
1 . 枚举类的作用
（1）用enum定义常量类型
（2）常量本身带有类型信息
（3）使用==操作符比较常量
2 . enum定义的类型
enum定义的类型实际上是class
（1）继承自java.lang.Enum
（2）不能通过new创建实例
（3）所有常量都是唯一实例（引用类型）
（4）可以用于switch语句
例如：
public enum Color {
RED, GREEN, BLUE;
}
//编译器编译出的class：
public final class Color extends Enum {
public static final Color RED = new Color();
public static final Color GREEN = new Color();
public static final Color BLUE = new Color();
private Color(){
}
}在这里，如果我们直接编写class编译器是不通过的，Java的enum是一种特殊语法，编译器会进行特殊的处理
3 . name()和ordinal()
（1）name()：获取常量定义的字符串（不要使用toString()）
（2）ordinal()：返回常量定义的顺序（无实际意义）
package com.feiyangedu.sample;
public enum Weekday {
SUN, MON, TUE, WED, THU, FRI, SAT;
}
package com.feiyangedu.sample;
public class Main {
public static void main(String[] args) {
for (Weekday day : Weekday.values()) {
System.out.println(day.name());
}
Weekday fri = Weekday.FRI;
// enum -> String:
System.out.println("FRI.name() = " + fri.name());
// 定义时的序号:
System.out.println("FRI.ordinal() = " + fri.ordinal());
// String -> enum:
System.out.println(Weekday.valueOf("FRI").name());
// 不存在的name:
Weekday.valueOf("ABC");
}
}4 .为enum编写构造方法、字段和方法
构造方法必须申明为private
例如：
package com.feiyangedu.sample;
public enum Weekday {
SUN("星期日"), MON("星期一"), TUE("星期二"), WED("星期三"), THU("星期四"), FRI("星期五"), SAT("星期六");
private String Chinese;
private Weekday(String Chinses) {
this.chinese = chinese;
}
public String toChinese() {
return chinese;
}
}
package com.feiyangedu.sample;
public class Main {
public static void main(String[] args) {
Weekday fri = Weekday.FRI;
System.out.println(fri.toChinese());//星期五
}（六）常用工具类
1 . Math
（1）Math类提供了数学计算的静态方法：
Math.pow(2,10);
Math.sqrt(2);
Math.exp(2);
Math.log(4);
Math.log10(100);
Math.sin(Math.PI / 6);//sin(π/6) = 0.5
Math.cos(Math.PI / 3);//cos(π/3) = 0.5（2）Math类提供了一些常量：
①PI = 3.14159…
②E = 2.71828…
（3）Math.random()
Math.random()方法用于生成一个随机数
①这个随机数介于0和1之间0 <= random < 1
②可用于生成某个区间的随机数
//0 <= R < 1
double x1 = Math.random();//首先生成一个随机数
//MIN <= R < MAX
long MIN = 1000;
Long MAX = 9000;
double x2 = Math.random() * (MAX - MIN) + MIN;
double r = (long) x2;2 . Random
Random类用来创建伪随机数
Random r = new Random();
r.nextInt();//生成下一个随机int
r.nextLong();//生成下一个随机long
r.nextFloat();//生成下一个随机float，介于0~1之间
r.nextDouble();//生成下一个随机double，介于0~1之间
r.nextInt(10);//生成0~10的随机数（不包括10）
r.nextInt(N);//生成不大于N的随机数伪随机数的概念：
（1）给定种子后伪随机数算法会生成完全相同的序列
例如我们给定一个种子为12345：
Random r = new Random(12345);
for(int i = 0; i < 10; i++){
System.out.println(r.nextInt(100));
}//51, 80, 41, 28...（2）不给定种子时Random使用系统当前时间戳作为种子
3 . SecureRandom
如果我们需要使用安全的随机数，可以使用JDK提供的SecureRandom
SecureRandom sr = new SecureRandom();
for(int i = 0; i < 10; i++){
System.out.println(sr.nextInt(100));
}SecureRandom的缺点是运行较为缓慢
4 . BigInteger
JDC提供了BigInteger用来表示任意大小的整数
BigInteger bi = new BigInteger("1234567890");
System.out.println(bi.pow(5));5 . BigDecimal
JDC提供了BigDecimal用来表示任意精度的浮点数
BigDecimal bd = new BigDecimal("123.10");
System.out.println(bd.multiply(bd));下面是一些演示：
package com.feiyangedu.sample;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.security.SecureRandom;
import java.util.Random;
public class Main {
public static void main(String[] args) {
// Math
System.out.println(Math.sqrt(2)); // 1.414
// Random
Random rnd = new Random(123456);
System.out.println(rnd.nextInt());
System.out.println(rnd.nextInt());
// SecureRandom
SecureRandom sr = new SecureRandom();
System.out.println(sr.nextInt());
System.out.println(sr.nextInt());
// BigInteger
BigInteger bi = new BigInteger("1234567890");
System.out.println(bi.pow(5));
// BigDecimal
BigDecimal bd = new BigDecimal("123.10");
System.out.println(bd.multiply(bd));
}
}上一篇： Java实现聊天机器人