业内经常说的一句话是不要重复造*，但是有时候，只有自己造一个*了，才会深刻明白什么样的*适合山路，什么样的*适合平地！
我将会持续更新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接口）和数据共享（里面的变量全是常量）的作用；
抽象类和接口相同点：
都不能被实例化；
都可以定义静态常量；
文中若有不正之处，欢迎批评指正！