JAVA基础第三章-类与对象、抽象类、接口

业内经常说的一句话是不要重复造轮子，但是有时候，只有自己造一个轮子了，才会深刻明白什么样的轮子适合山路，什么样的轮子适合平地！

我将会持续更新java基础知识，欢迎关注。

往期章节：

JAVA基础第一章-初识java

JAVA基础第二章-java三大特性：封装、继承、多态

---

类与对象

什么是类？

类是抽象的概念集合，表示的是一个共性的产物，类之中定义的是属性和行为（方法）。

什么是对象？

对象是一种个性的表示，表示一个独立的个体，每个对象拥有自己独立的属性，依靠属性来区分不同对象。

所以总结来说的话，类是对象的模板，对象是类的实例。

举个例子：

人类就是一个类（class），你，我，他就是每一个人类的实例。我们每一个个体的最基本的属性有姓名、性别、体重、身高等。

具体的代码表现如下：

 public class Human
 {
     private String name;
     private String sex;
     private int weight;
     private int heiht;

     public static void main(String[] args)
     {
         Human me = new Human();
         me.setName("JJ");
         me.setSex("man");
         me.setHeiht(198);  //我的理想身高~0.0
         me.setWeight(180);

         Human he = new Human();
         he.setName("name");
         he.setSex("man");
         he.setHeiht(180);
         he.setWeight(150);
     }

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public int getWeight() {
         return weight;
     }

     public void setWeight(int weight) {
         this.weight = weight;
     }

     public int getHeiht() {
         return heiht;
     }

     public void setHeiht(int heiht) {
         this.heiht = heiht;
     }
 }

从上面的代码我们可以看到，在main函数中，我们通过 new 关键字新建了2个对象。一个是me，一个是he，我们都来自Human类，但是我们具有不同的属性，我们除了性别相同，其他的属性完全不同。

这里特别再提到一点就是我们在 new 一个对象的时候后面的 Human() 函数，我们称之为构造函数（方法）。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

每个类都有构造函数。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。所以从上面代码可以看到，我们并没有指定构造函数，而是采用了默认的。

多个构造函数的写法，代码表现如下：

 //每次新建的时候直接先设置性别，那么当前新建的对象就不用再设置性别属性
     public Human(String sex)
     {
         this.sex = sex;
     }

     //这个构造函数和默认构造函数相同，不传任何参数
     public Human()
     {

     }

如果我们没有声明构造函数，那么编译器会为我们提供一个默认无参的构造函数；如果我们声明了构造函数，不管几个，那么编译器就不再为我们提供默认的构造函数。

抽象类

使用了关键词 abstract 声明的类叫作“抽象类”。如果一个类里包含了一个或多个抽象方法，类就必须指定成abstract（抽象）。“抽象方法”,属于一种不完整的方法，只含有一个声明，没有方法主体。

具体代码表现如下：

 public abstract class Human
 {
     private String name;
     private String sex;
     private int weight;
     private int heiht;

     public abstract String sayHello();

     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public int getWeight() {
         return weight;
     }

     public void setWeight(int weight) {
         this.weight = weight;
     }

     public int getHeiht() {
         return heiht;
     }

     public void setHeiht(int heiht) {
         this.heiht = heiht;
     }
 }

从上面的代码中我们可以看到类名称前面添加了abstract  关键字，抽象方法sayHello 前面也添加了关键字abstract，  同时这个方法不能写方法体。

包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。

抽象类和普通类的主要一些区别：

抽象方法权限必须为public或者protected，因为如果为private，则不能被子类继承，子类便无法实现该方法，缺省情况下默认为public。

抽象类不能创建对象，也就是不能通过new实例化；

如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。

如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

在其他方面，抽象类和普通的类并没有区别。

接口

说起接口，那么很多时候我们就会和抽象类相比较，而且这个问题也是很多初级javaer，经常会被问到的面试问题。

接口（英文：Interface）：在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以 interface 来声明。一个类通过继承（实现）接口的方式，从而来继承接口的抽象方法。

具体的代码表现如下：

 /**
  *  动物接口
  * @author JJJ
  *
  */
 public interface Animals
 {
     //接口内的静态成员常量
      static String eyes = "1";
      static final String leg = "2";
      //吃东西
      public void eatFood();
 }

在上面我们已经制定了一个 Animals 接口，而人类作为高级动物，必然也是需要吃东西，下面我们就让人类实现 Animals 接口，具体代码如下：

 public  class Human implements Animals
 {
     private String name;
     private String sex;
     private int weight;
     private int heiht;
     public String getName() {
         return name;
     }

     public void setName(String name) {
         this.name = name;
     }

     public String getSex() {
         return sex;
     }

     public void setSex(String sex) {
         this.sex = sex;
     }

     public int getWeight() {
         return weight;
     }

     public void setWeight(int weight) {
         this.weight = weight;
     }

     public int getHeiht() {
         return heiht;
     }

     public void setHeiht(int heiht) {
         this.heiht = heiht;
     }

     public String eatFood()
     {
         return "今天我吃了米饭！";
     }
 }

看上面的代码第39行~我们重新实现了接口中的 eatFood 方法，并且写上了方法体。

另外在这里要说明一下，在 Animals 接口中我们声明了2个静态的成员变量eyes和 leg，后者被 final 修饰，在上一章节中我们说过凡是被 final 修饰的一旦初始化，就不可以更改。

那么 eyes 是不是就可以修改呢？

从上图可以看出，答案是不行~即使你在声明的时候没有显示的写 final ，在接口中依然会把这个变量归为常量，所以接口中的属性必然是常量，只能读不能改，这样才能为实现接口的对象提供一个统一的属性。

抽象类与接口的区别：

接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法；

一般的应用程序中，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现；

一个类只能继承一个父类，但可以通过继承（实现）多个接口实现多重继承，接口还有标识（里面没有任何方法，如序列化 java.io.Serializable接口）和数据共享（里面的变量全是常量）的作用；

抽象类和接口相同点：

都不能被实例化；

都可以定义静态常量；

---

文中若有不正之处，欢迎批评指正！