Java第三阶段

Object类

Object类是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

简单来说就是，Object类是所有类的父类，包括我们所写的类，我们在使用类的时候就会利用Object类中的方法

Object类常用方法

publi final native class<?>getClass()   //返回此Obect运行时的类
public native int hashCode()           //返回对象的哈希码
public boolean equals(Object obj)  //判断其他对象与此对象是否相等
protected native Object clone()throes CloneNotSupportedException  //创建并返回此对象的一个副本
public String toString()  //返回对象的字符串表示
public final native void notify()  //唤醒在此对象监视器上等待的单个线程
public final native void notifyAll()  //唤醒在此对象监视器上等待的所有线程
public final native void wait(long timeout) throws InterruptedException  //使当前对象的线程等待timeout时长
public final void wait(long timeout， int nanos) throws InterruptedException //使当前对象的线程等待timeout时长,或其他线程中断当前线程
public final void wait() throws InterruptedException  //使当前对象的线程等待
protected void finalize() throws Throwable{}  //垃圾回收时调用该方法 

强制类型转换

                         基本数据类型转换规则

以下例子展示了如何进行类型强转

public class Haha{
   public static void main(String args[]){
     float a = 3.14f;
     double b = a;      //float类型的自动转换为double
     int c = (int)a;   //float类型强制转换为int
     int d = (int)e;  //double类型的强制转换为int

继承

在 Java 中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。

利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。

继承的语法规则如下：

[修饰符] class 子类名 extends 父类名 

封装

在面向对象程式设计方法中，封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

• 1. 良好的封装能够减少耦合。
• 2. 类内部的结构可以自由修改。
• 3. 可以对成员变量进行更精确的控制。
• 4. 隐藏信息，实现细节。

实现Java封装的步骤

1… 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Student{
  private String name;
  private int score;
}
//这段代码中name和score的属性是私有的，只有本类可以访问

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public calss Student{
  private String name;
  private int score;
  
  public int getScore(){
    return score;
  }
  
  public String getName(){
    return name;
  }
  
  public void setScore(int score){
     this.score = score; 
  }
  
   public void setName(String name){
     this.name = name; 
  }
} 

以上实例中public方法是外部类访问该类成员变量的入口。通常情况下，这些方法被称为getter和setter方法。
通过如下的例子说明Student类的变量怎样被访问：

public class Haha{
   public static void main(String args[]){
   Student stu = new Student();
   stu.setScore(100);
   stu.setName("Jake");
   System.out.print("Name : " + stu.getName()+ 
                             " Score : "+ stu.getScore());
    }
}
//运行结果：Name：Jake  Score：100

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作。

多态存在的三个条件

1.存在继承关系

2.子类要重写父类的方法

3.父类数据类型的引用指向子类对象

Animal a = new Cat();  //向上转型
//此操作后，其他类访问子类对象的成员属性，访问到的是父类的成员属性
//访问子类对象的非静态成员方法，访问到的是子类

多态的弊端

不能使用子类特有的成员属性和子类特有的成员方法。

使用子类中特有方法或特有属性：使用类型强转。

Cat b = (Cat) a;    //向下转型 

抽象（Abstract ）

抽象类

一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。

由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。

父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。

在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

抽象方法

抽象方法只包含一个方法名，而没有方法体。

public abstract int computPay();

1. 如果一个类包含抽象方法，那么该类必须是抽象类。
2. 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

注意：

1、 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

2、构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。

重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。

规则

1、参数列表必须完全与被重写方法的相同。

2、返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类。

3、访问权限不能比父类中被重写的方法的访问权限更低。

访问权限：指是本类的成员变量、成员方法和内部类对其他类的可见性。

Java一共有四种访问权限，按照权限由大到小分别为public、protected、default和private，如果省略了访问修饰符，那访问权限就是defualt。

4、父类的成员方法只能被它的子类重写。

5、声明为 final 的方法不能被重写。

6、声明为 static 的方法不能被重写，但是能够被再次声明。

7、子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。

8、子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。

9、重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

10、构造方法不能被重写。

11、如果不能继承一个方法，则不能重写这个方法。

*****当需要在子类中调用父类的被重写方法时，要使用 super 关键字。 *****

重载

重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

以下例子演示方法的重载

运行结果

重写和重载的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

覆盖

如果在子类中定义一个方法，其名称、返回类型及参数签名正好与父类中某个方法的名称、返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。

注意

1、子类方法的权限必须不小于父类方法的权限。

2、子类方法只能抛出父类方法声明抛出的异常或异常子类。

3、子类方法不能覆盖父类中声明为final或static的方法。

4、子类方法必须覆盖父类中声明为abstract的方法（接口或抽象类）。

以下例子演示：

运行结果：

装箱拆箱

八种基本数据类型 byte ,short,int,long,char,float,double,boolean 都不具备对象的特性,没有方法可以调用。因此每种基本数据类型有对应的类，称之为包装类。

基本数据类型对应的包装类

基本数据类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double
boolean	Boolean

自动拆箱装箱

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。

//自动装箱
Integer i = 99;
//自动拆箱
int j = i;