Java抽象类以及Object类

Object概述

• Object类是Java语言中的根类,(即所有类的父类),它描述的所有方法子类都可以使用,所有类在创建对象的时候,最终找的父类就是Object类.
• Boolean equals(Object obj)
  • 指示其他某个对象是否与此对象"“相等.”"
• int hashCode()
  • 返回该对象哈希码值.
• Class<?> getClass()
  • 返回此Object的运行时类
• String toString()
  • 返回该对象的字符串表示.
• 所有的类都可以使用Object里面的方法

抽象类

抽象类的产生

• 当编写一个类时,我们往往会为该类定义一些方法,这些方法是用来描述该类的功能具体实现方式,所以这些方法都有具体的方法体.

• 分析事物时，发现了共性内容，就出现向上抽取。会有这样一种特殊情况，就是方法功能声明相同，但方法功能主体不同。那么这时也可以抽取，但只抽取方法声明，不抽取方法主体。那么此方法就是一个抽象方法.

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

• 抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样，由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类

• **注意:**在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口.

抽象类与抽象方法的定义

• 抽象方法定义的格式

public abstract 返回值类型 方法名(参数列表);

• 抽象类的定义格式

public abstract class 类名{
}

• 举例说明:
• JavaEE工程师和 Android 工程师之间有共性，可以进行向上抽取。抽取它们的所属共性类型：研发部员工。由于 JavaEE 工程师和 Android 工程师都具有工作功能，但是他们具体工作内容却不一样。这时在描述研发部员工时，发现了有些功能（工作）不具体，这些不具体的功能，需要在类中标识出来，通过 Java 中的关键字 abstract(抽象)
• 当定义了抽象函数的类也必须被 abstract 关键字修饰，被abstract关键字修饰的类是抽象类

//研发部员工
public abstract class Developer{
	public abstract void work();//抽象函数(方法),需要abstract修饰,并分号,结束.
}
//JavaEE工程师
public class JavaEE extends Develper{
	public void work(){
		System.out.println("正在研发项目");
	}
}
//Android工程师
public class Android extends Developer{
	public void work(){
		System.out.println("正在研发手机端")
	}
}

抽象类的特点

• 1.抽象类和抽象法都需要被abstract修饰.抽象方法一定要定义在抽象类中.
• 2.抽象类不可以直接创建对象,原因:调用抽象方法没有意义.
• 3.只有覆盖了抽象类中所有的抽象方法后,其子类才可以创建对象,否则该子类还是一个抽象类.
• 4.之所以继承抽象类,更多的是在思想层面上,使面对共性类型操作会更简单.

抽象类的细节问题

• 抽象类一定是个父类?
  • 是的.因为不断抽取而来的.
• 抽象类中是否可以不定义抽象方法
  • 是可以的,那这个抽象类的存在到底有什么意义呢?不让该类创建对象,方法可以直接让子类去使用.
• 抽象类关键字abstract不可以和那些关键字共存?
  • private static final

抽象类举例

在Java语言中使用过abstract class来定义抽象类,和下面Employee类没什么不同,尽管该类是抽象类,但是它仍然有3个成员变量,7个成员方法和1个构造方法

public abstract class Employee{
//定义成员变量
  private String name;
  private String address;
  private int number;
  //定义构造方法
  public Employee(String name,String address,int number){
  	Systrm.out.println("构建员工"+name);
  	this.name=name;
  	this.adderss = adderss;
  	this.number = number;
  }
  //-----成员方法 Begin---------------------------------------------------------------
  public double computePay(){
  	System.out.println("内部员工 computePay");
  	retrun0.00;
  }
  public void mailCheck(){
  	System.out.println("邮寄到 " + this.name + " " + this.address);
  }
   @Override
    public String toString() {
        return name + " " + address + " " + number;
    }
    public String getName() {
        return name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String newAddress) {
        address = newAddress;
    }

    public int getNumber() {
        return number;
    }
}

如果直接使用该类,编译时会报错.

继承抽象类

• 可以通过一般的方法继承Employee类

public class Salary extends Employee{
	private double salary;
	public Salary(String name, String address, int number, double salary){
		super(name,adderss,number);
		setSalaty(salary);
	}
	@Override
	public voidmailCheck(){
		System.out.println("检查工资类邮件");
		System.out.println("支付 " + getName() + " 的薪资 " + salary);
	}
	public double getSalary() {
        return salary;
    }
	public void setSalary(double newSalary) {
        if (newSalary >= 0.0) {
            salary = newSalary;
        }
    }
    @Override
    public double computePay() {
        System.out.println("计算并支付工资给 " + getName());
        return salary / 52;
    }
}

• 尽管不能实例化一个 Employee 类的对象，但是如果我们实例化一个 Salary 类对象，该对象将从 Employee 类继承 7 个成员方法，且通过该方法可以设置或获取 3 个成员变量.

package com.funtl.oop.demo6;

public class AbstractDemo {
    public static void main(String[] args) {
        Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
        Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);

        System.out.println("调用 Salary 类的 mailCheck 方法");
        s.mailCheck();

        System.out.println("调用 Employee 类的 mailCheck 方法");
        e.mailCheck();
    }
}

上述说明

构建员工 Mohd Mohtashim
构建员工 John Adams
调用 Salary 类的 mailCheck 方法
检查工资类邮件 
支付 Mohd Mohtashim 的薪资 3600.0
调用 Employee 类的 mailCheck 方法
检查工资类邮件 
支付 John Adams 的薪资 2400.0

抽象方法

如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法，abstract 关键字同样可以用来声明抽象方法.

• 抽象方法只包含一个方法名，而没有方法体
• 抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号

public abstract class Employee {
    private String name;
    private String address;
    private int number;

    // 声明抽象方法
    public abstract double computePay();

    // 其余代码
}

声明抽象方法会造成以下两个结果

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

注意:继承抽象方法的子类必须重写该方法.否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象.

public class Salary extends Employee {
    // 年薪
    private double salary;

    // 必须实现抽象方法
    @Override
    public double computePay() {
        System.out.println("计算并支付工资给 " + getName());
        return salary / 52;
    }
    
    // 其余代码
}

抽象类总结

• 1.抽象类不能被实例化,如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象.
• 2.抽象类中不一定包含抽象方法,但是有抽象方法的类必定是抽象类,
• 3.抽象类中的抽象方法只是声明,不包括方法体,就是不给出方法的具体实现也就是方法的具体功能,
• 4.构造方法,类方法(用static修饰的方法)不能声明为抽象方法.
• 5.抽象类的子类必须给出抽象类中的抽象方法的具体实现,除非该子类也是抽象类.