java 面向对象的理解（简述java面向对象的三个基本特征）

抽象类和接口

面向对象程序设计（oop）目前已经接近尾声，这个小结我们再介 绍两个重要的概念。

java中除了类，还有抽象类和接口这两个概念，这其中有很多值得我们学习的地方，在理解和思考之前我们先用一个小结给大家看看java中怎么定义抽象类和接口。

（1） 抽象方法和抽象类的定义

一般的方法：

public class animal { public void eat(){
				system.out.println("animal is eating.");
}

抽象方法：

public abstract class animal { abstract void eat();
}

abstract void eat(); 去掉方法体，加一个abstract 关键字就是一个抽象方法，如果一个类里有抽象方法，在类的声明上必须也要加上abstract ，变成一个抽象类。我们要注意的是，抽象方法没有方法体，所以不能直接调用，也正是因为抽象方法没有方法体，所以我们不能直接构造一个抽象类。

其实值得我们思考的问题是，一个方法连方法体也没有，这究竟有什么用。答案是【约定】。

我们不能【直接构造抽象类】，但是子类可以继承抽象类，并且必须重写抽象方法，除非子类也是抽象类。这样就会对所有子类有了共同约束，同时父类已经实现的方法也能被所有的子类所复用。

顾名思义：

public abstract class animal { abstract void eat();
}

这个抽象方法是为了约束子类的，让子类必须实现这个方法。抽象类中除了拥有抽象方法，也可以拥有普通方法。

public abstract class animal { 
				abstract void eat();
        public void print(){
                system.out.println("i'm an animal!");
        }
}

抽象类无法直接进行实例化操作，当一个类实例化之后，就意味着这个对象可以调用类中的属性或者方法了，但在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。既然无法进行方法调用的话，又怎么去产生实例化对象呢。

抽象类里中也可以和其他类一样拥有自己的成员变量：

public abstract class animal { 
				private string name;
}

既然有成员变量，我们大致可以猜出抽象类是可以构造的，因为属性必须通过new去内存分配空间才能赋值啊。

那么抽象类中一定存在构造方法，实例化的过程就是属性赋值的过程啊！

看一下下边的例子：

public abstract class animal {
        // 但是我们不能直接new public animal(){
        system.out.println("animal has created!");
        }
        abstract void eat();
        public void print(){ 
        				system.out.println("i'm an animal!");
        }
}
public class cat extends animal {
        public cat(){
        				system.out.println("cat has created!");
        }

        @override
        void eat() {
                system.out.println("cat is eating!");
        }

        public static void main(string[] args) {
        				new cat();
        }
}

结果：
animal has created! 
cat has created!

这个过程说明了，创建子类时，父类依然会被创建，抽象类只有在构建子类的时候才会被构建出实例。

【小问题】：抽象类可以用final声明么？

抽象类存在的目的就是为了让子类去继承，一个类被final修饰了， 就失去了这个能力，结果当然是不行了。

总结一下

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

2. 抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；

3. 抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；

4. 子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；

（2） 接口的定义

其实接口是比抽象类更高级的抽象，当然抽象类也是比类更高级的抽象。接口中只能有方法的定义，而不能有实现：

public abstract class animal {
        /**
        * 呼吸的方法
        */
        public abstract void breath();
        /**
        * 吃的方法
        */
        public abstract void eat();
}

我们可以更加优雅的表达出来：

public interface animal {
        /**
        * 呼吸的方法
        */
        void breath();
        /**
        * 吃的方法
        */
        void eat();
}

abstrac 都不需要了，但是要使用关键字interface ，这种类我们称之为【接口】。

接口中能定义抽象方法，不能有实例字段、不能有方法实现（静态的可以），java8以后在接口中可以定义默认方法，这个我们先放一放以后再讲。编写接口的目的在于对类的某些能力进行约定和规范，接口不能被实例化，没有构造器。

接口中的方法默认是public的，我们也推荐使用默认的，也就是我们定义接口时，不用写它的权限修饰符。但是因为接口是契约、是约定子类必须具备的某些能力，是需要子类去实现的，所以我们在写借口时，推荐使用javadoc的方式给接口加注释。

接口是多实现的，一个类可以实现多个接口，但是只能继承一个类。接口之间也可以相互继承

（1） 深入理解

我们学习了几天的面向对象

继承是 is-a 的关系， dog is an animal。 man is a human。

实现是 can-do的关系， 实现更体现一个类的能力，通过实现多个接口是可以聚合多个能力的。

举一个例子：

【鸟能飞】和【飞机能飞】。它们有功能的特质吗？其实也不太有，当时它们都能飞。

我们在设计上就可以定一个接口，接口有fly的方法定义。

接口是可以多实现的，所以鸟和飞机除了实现飞行的接口还能实现很多其他的接口。这也就意味着它们can-do 很多事情。

抽象类是模板式的设计，而接口是契约式设计。

抽象类设计时往往就是将相同实现方法抽象在父类，由子类独立实现那些实现各自不同的实现。

【做好顶层设计】

**我我们规划蓝图，做好顶层设计，具体的实现具体来，只要跟着党的路线走就好了。

我们再举一个例子，比如食物链，动物会吃其他动物，也会被其他动物吃

//动物
public interface animal {
        /**
        * 吃的方法
        */
        void eat(animal animal);

        /**
        * 获取名字
        * @return
        */
        string getname();
}

//老虎
public class tiger implements animal {
        @override
        public void eat(animal animal) {
        				system.out.println(this.getname() + "吃了" + animal.getname());
        }

        @override
        public string getname() {
        				return "tiger";
        }
}
//狼
public class wolf implements animal { @override
        public void eat(animal animal) {
        				system.out.println(this.getname() + "吃了" + animal.getname());
        }

        @override
        public string getname() {
        				return "wolf";
        }
}
//羊
public class sheep implements animal { @override
        public void eat(animal animal) {
        				system.out.println(this.getname() + "吃了" +	animal.getname());
                @override
                public string getname() {
                				return "sheep";
                }
        public static void main(string[] args) {
                animal tiger = new tiger();
                animal wolf = new wolf(); 
                animal sheep = new sheep(); 
                wolf.eat(sheep); tiger.eat(wolf);
        }
}
结果：
//wolf吃了sheep
//tiger吃了wolf

公司里边，牛逼的人写接口。接口更多的是设计的工作，实现更多是搬砖的工作。