JAVA基础第三章-类与对象、抽象类、接口 JAVA基础第一章-初识java JAVA基础第二章-java三大特性：封装、继承、多态

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

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

 

往期章节：

JAVA基础第一章-初识java

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

 

---

 

类与对象

什么是类？

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

什么是对象？

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

因此总结来讲的话，类是对象的模板，对象是类的实例。

举个例子：

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

具体的代码表现以下：

 1 public class Human 
 2 {
 3     private String name;
 4     private String sex;
 5     private int weight;
 6     private int heiht;
 7     
 8     
 9     public static void main(String[] args)
10     {
11         Human me = new Human();
12         me.setName("JJ");
13         me.setSex("man");
14         me.setHeiht(198);  //个人理想身高~0.0
15         me.setWeight(180);
16         
17         Human he = new Human();
18         he.setName("name");
19         he.setSex("man");
20         he.setHeiht(180);  
21         he.setWeight(150);
22     }
23     
24     
25     public String getName() {
26         return name;
27     }
28 
29     public void setName(String name) {
30         this.name = name;
31     }
32 
33     public String getSex() {
34         return sex;
35     }
36 
37     public void setSex(String sex) {
38         this.sex = sex;
39     }
40 
41     public int getWeight() {
42         return weight;
43     }
44 
45     public void setWeight(int weight) {
46         this.weight = weight;
47     }
48 
49     public int getHeiht() {
50         return heiht;
51     }
52 
53     public void setHeiht(int heiht) {
54         this.heiht = heiht;
55     }
56 }

从上面的代码咱们能够看到，在main函数中，咱们经过 new 关键字新建了2个对象。一个是me，一个是he，咱们都来自Human类，可是咱们具备不一样的属性，咱们除了性别相同，其余的属性彻底不一样。

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

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

每一个类都有构造函数。若是没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。因此从上面代码能够看到，咱们并无指定构造函数，而是采用了默认的。

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

 1 //每次新建的时候直接先设置性别，那么当前新建的对象就不用再设置性别属性
 2     public Human(String sex)
 3     {
 4         this.sex = sex;
 5     }
 6     
 7     //这个构造函数和默认构造函数相同，不传任何参数
 8     public Human()
 9     {
10         
11     }

若是咱们没有声明构造函数，那么编译器会为咱们提供一个默认无参的构造函数；若是咱们声明了构造函数，无论几个，那么编译器就再也不为咱们提供默认的构造函数。 

 

 

抽象类

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

具体代码表现以下：

 1 public abstract class Human 
 2 {
 3     private String name;
 4     private String sex;
 5     private int weight;
 6     private int heiht;
 7     
 8     public abstract String sayHello();
 9     
10     public String getName() {
11         return name;
12     }
13 
14     public void setName(String name) {
15         this.name = name;
16     }
17 
18     public String getSex() {
19         return sex;
20     }
21 
22     public void setSex(String sex) {
23         this.sex = sex;
24     }
25 
26     public int getWeight() {
27         return weight;
28     }
29 
30     public void setWeight(int weight) {
31         this.weight = weight;
32     }
33 
34     public int getHeiht() {
35         return heiht;
36     }
37 
38     public void setHeiht(int heiht) {
39         this.heiht = heiht;
40     }
41 }

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

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

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

抽象方法权限必须为public或者protected，由于若是为private，则不能被子类继承，子类便没法实现该方法，缺省状况下默认为public。

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

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

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

在其余方面，抽象类和普通的类并无区别。

 

接口

提及接口，那么不少时候咱们就会和抽象类相比较，并且这个问题也是不少初级javaer，常常会被问到的面试问题。

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

具体的代码表现以下：

 1 /**
 2  *  动物接口
 3  * @author JJJ
 4  *
 5  */
 6 public interface Animals 
 7 {
 8     //接口内的静态成员常量
 9      static String eyes = "1";
10      static final String leg = "2";
11      //吃东西
12      public void eatFood();
13 }

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

 1 public  class Human implements Animals
 2 {
 3     private String name;
 4     private String sex;
 5     private int weight;
 6     private int heiht;
 7     public String getName() {
 8         return name;
 9     }
10 
11     public void setName(String name) {
12         this.name = name;
13     }
14 
15     public String getSex() {
16         return sex;
17     }
18 
19     public void setSex(String sex) {
20         this.sex = sex;
21     }
22 
23     public int getWeight() {
24         return weight;
25     }
26 
27     public void setWeight(int weight) {
28         this.weight = weight;
29     }
30 
31     public int getHeiht() {
32         return heiht;
33     }
34 
35     public void setHeiht(int heiht) {
36         this.heiht = heiht;
37     }
38 
39     public String eatFood() 
40     {
41         return "今天我吃了米饭！";
42     }
43 }

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

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

那么 eyes 是否是就能够修改呢？

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

抽象类与接口的区别：

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

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

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

抽象类和接口相同点：

都不能被实例化；

均可以定义静态常量；

 

 

 

---

 

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