黑马程序员——java基础之抽象与接口

——- android培训、java培训、期待与您交流！ ———-

“动物”
abstract:抽象。可以用来修饰类。修饰类之后这个类就是“抽象类”
修饰类之后，这个类就不能再创建对象了。
    抽象类的特点：
        1.不能实例化。(有构造方法)
        2.抽象类可以被继承，也可以继承。抽象类也是单继承，也可以多层继承。

    类与抽象类的区别：
        1.抽象类不能被实例化。
        2.抽象类可以包含抽象方法。

class Fu {

}

class Fu2 {

}

abstract class Animal {

}

class Cat extends Animal {

}

class AbstractDemo {
    public static void main(String[] args) {
        //Cat c = new Cat();
        //Animal a = new Animal();
    }
}

抽象方法：abstract
    1.抽象方法所在的类必须是抽象类。
    2.抽象方法没有方法体。
    3.继承时，子类必须重写父类的抽象方法。(如果子类也是抽象的，可以不用重写。)
        强制要求子类做某事。


    abstract关键字的注意事项：
        1.不能修饰属性。
        2.private不能和abstract一块使用。
        3.final不能和abstract一块使用。
        4.static不能和abstract一块使用。

abstract class Animal {
    //abstract String name;
    //static abstract void eat();

    public abstract static void test();
}

class Cat extends Animal {
    public void eat(){}
}
abstract class Dog extends Animal {

}

class AbstractMethodDemo {
    public static void main(String[] args) {
        //Dog d = new Dog();
        //d.eat();
        Animal.test();
    }
}

老师案例
具体事物：
    基础班老师，就业班老师
    共性：姓名，年龄，
        讲课。

动态绑定：java在编译的时候，

//教师父类
abstract class Teacher {
    String name;
    int age;

    public abstract void teach();
}
//基础班老师
class JCTeacher extends Teacher {
    public void teach(){
        System.out.println("教基础班");
    }
}
//就业班老师
class JYTeacher extends Teacher {
    public void teach(){
        System.out.println("教就业班");
    }
}

class TeacherDemo {
    public static void main(String[] args) {
        /*
        JCTeacher j = new JCTeacher();
        j.teach();
        */
        //使用多态
        //Teacher t;
        //执行子类对象
        //t = new JCTeacher();
        Teacher t = new JCTeacher();
        t.teach();
    }
}

抽象类和普通类的区别：

结构：
抽象类：abstract修饰
普通类：没有abstract

成员组成：
1.成员变量：
    抽象类和普通类一样，都有;
2.常量：
    抽象类和普通类一样。都有。
3.成员方法：
    抽象类和普通类一样。都有。
4.抽象方法：
    只能放在抽象类中。
5.构造方法：
    抽象类和普通类都有，但是抽象类不能创

学生案例
具体事务：基础班学员，就业班学员
共性：姓名，年龄，学习，吃饭

abstract class Student {
    String name;
    int age;
    //学习
    public abstract void study();
    //吃饭
    public abstract void eat();
}
class JCStudent extends Student {
    public void study(){
        System.out.println("学习基础");
    }

    public void eat(){
        System.out.println("黄焖鸡米饭");
    }
}

class JYStudent extends Student  {
    public void study(){
        System.out.println("学习就业");
    }

    public void eat(){
        System.out.println("海底捞");
    }
}

class StudentDemo {
    public static void main(String[] args) {
        Student s = new JCStudent();
        s.eat();
    }
}

葵花宝典：

abstract class 葵花宝典 {
    public abstract void 自宫();
}

class 东方不败 extends 葵花宝典  {
    public void 自宫(){
        System.out.println("天生的，不需要");
    }
}

class 岳不群 extends 葵花宝典  {
    public void 自宫(){
        System.out.println("剪刀……");
    }
}

class 林平之 extends 葵花宝典  {
    public void 自宫(){
        System.out.println("指甲剪……");
    }
}


class 葵花宝典练习 {
    public static void main(String[] args) {
        //创建一个东方不败
        葵花宝典 东方菇凉 = new 东方不败();
        东方菇凉.自宫();
        //创建一个岳不群
        葵花宝典 小岳岳 = new 岳不群();
        小岳岳.自宫();
        //林平之
        葵花宝典 小林子 = new 林平之();
        小林子.自宫();
    }
}

猫狗案例
    eat()方法。
    sleep()方法

接口：java中的类是不能多继承的，为了解决这个问题，所以就有了接口。 

//定义一个动物类
class Animal {
    public void eat(){}
    public void sleep(){}
}

//单独写一个类，存储抓老鼠方法
class CatchMouse {
    public void catchMouse(){}
}

//猫类
class Cat extends Animal {
}
//狗类
class Dog extends Animal {
}


class AnimalDemo {
    public static void main(String[] args) {

    }
}

接口（interface）：
    接口是一种比抽象类更加抽象的“类”结构。
        接口不是类，也不是类的一部分，是和类平级的一种结构
    接口的格式：
        interface 接口名{}

    接口中只能有抽象方法。

接口中成员的特点：
    成员变量：默认的修饰符public static final
        接口中成员变量的访问修饰符只能public static final ，而且必须是这3个。
    成员方法：默认访问修饰符public abstract
        成员方法必须是抽象方法。
    构造方法：
        不能创建对象。接口没有构造方法。

接口的实现：
    接口与类之间的关系叫做“实现”，关键字是implements
    格式：
        class 类 implements 接口{

        }

    实现接口：
        1.重写接口中的所有抽象方法。（如果本类是抽象类，则不需要重写）
        2.接口可以多实现。也可以多层实现。
        3.接口与接口是继承关系。


接口的使用：通过多态使用

interface Inter {
    public int a = 10;
    void test();
    void method();
}

class Test implements Inter{
    public void test(){}
    public void method(){}
}

class InterfaceDemo {
    public static void main(String[] args) {
        //System.out.println(Inter.a);
        //Inter.a = 11;
        //Inter i = new Inter();

        //Test t = new Test();
        //t.test();

        /*
            1.有继承或实现关系
            2.有方法重写
            3.父类（父接口）引用指向子类对象。
        */

        Inter i = new Test();
        i.test();
    }
}

一个类可以即继承一个类，又实现一个或多个接口。
    这个时候必须先继承然后再实现。

//定义一个动物类
class Animal {
    public void eat(){}
    public void sleep(){}
}

//单独写一个类，存储抓老鼠方法
interface CatchMouse {
    public void catchMouse();
}

interface UpTree {
    public void tree();
}

//猫类
class Cat extends Animal implements CatchMouse{
    public void catchMouse(){}
    public void tree(){}
}
//狗类
class Dog extends Animal {
}

class CatchMouseInterDemo {
    public static void main(String[] args) {

    }
}

类与类：
继承关系。只能单继承，可以多层集成。
类与接口之间：
实现关系，类实现了接口。
可以多实现。
可以多层实现。
接口与接口：
继承关系。
可以多继承


接口与抽象类之间的区别：
成员变量：
    抽象类：可以有，普通成员变量、常量
    接口：只能有常量。
成员方法：
    抽象类，可以有普通方法，也可以有抽象方法
    接口：只能有抽象方法。
构造方法：
    抽象类：有构造方法，本身不能创建对象。
    接口：根本就没有构造方法。
设计理念：
    抽象类与类之间是继承关系。体现的是"is a"的关系，着重强调继承。
    接口与类之间是实现关系。体现的是"like a(contain a)",着重强调的是拥有的关系。

猫狗案例，猫和狗都可以
eat。sleep
jump //这个使用接口实现

interface Jump {
    //跳高方法
    public void jump();
}

abstract class Animal {
    //吃饭
    public abstract void eat();
    //睡觉
    public void sleep(){
        System.out.println("天黑请闭眼");
    }
}
//猫
class Cat extends Animal implements Jump {
    public void eat(){
        System.out.println("<。)#)))≦");
    }

    public void jump(){
        System.out.println("猫跳高");
    }
}
//狗
class Dog extends Animal implements Jump  {
    public void eat(){
        System.out.println("肉");
    }

    public void jump(){
        System.out.println("狗跳墙");
    }
}

class AnimalTest {
    public static void main(String[] args) {
        //通过多态使用接口
        Jump j = new Cat();
        j.jump();
        //j.sleep();
        Animal a = (Animal)j;
        a.sleep();

        //a.jump();

        Cat c = new Cat();
        c.jump();
        c.sleep();
        c.eat();
    }
}

链式编程

class Animal {
    public static Cat getCat() {
        return new Cat();
    }
}
class Cat {
    public void catSay(){
        System.out.println("喵喵");
    }
}
class Test2 {
    public static void main(String[] args) {
        System.out.println(Animal.getCat());
        //Cat c = Animal.getCat();
        //c.catSay();
        Animal.getCat().catSay();
    }
}

//人类
class Person {
    String name;
    int age;
}
//教练
abstract class Coach extends Person {
    //教的方法
    public abstract void teach();
}

//运动员
abstract class Player extends Person {
    //运动的方法
    public abstract void play();
}

//乒乓球教练
class PPCoach extends Coach implements Study {
    public void teach(){
        System.out.println("教乒乓球");
    }

    public void studyEnglish(){
        System.out.println("教练学习英语");
    }
}

//篮球教练
class LQCoach extends Coach{
    public void teach(){
        System.out.println("教篮球");
    }
}

//乒乓球运动员
class PPlayer extends Player  implements Study  {
    public void play(){
        System.out.println("玩乒乓球");
    }


    public void studyEnglish(){
        System.out.println("运动员学习英语");
    }
}

//篮球运动员
class LPlayer extends Player {
    public void play(){
        System.out.println("玩篮球");
    }
}
//学习英语接口
interface Study {
    public void studyEnglish();
}

class CoachPlayerDemo {
    public static void main(String[] args) {
        /*
        PPCoach p = new PPCoach();
        p.teach();
        p.studyEnglish();


        Coach c = new PPCoach();
        c.teach();
        */
        Study s = new PPCoach();
        s.studyEnglish();
    }

    public static Study test(){
        return new PPCoach();
    }

    public static void test(Study s){

    }

}

总结：

抽象类：
格式：abstract class 类名{}
特点：
    1.不能实例化。（有构造方法。）
    2.继承抽象类的子类必须重写抽象类中的所有抽象方法，除非子类也是抽象的。
抽象方法：
在普通方法的访问修饰符上增加abstract。
特点：
    1.抽象方法不能有方法体。
    2.抽象方法必须在抽象类中。
    3.子类必须重写所有的抽象方法。除非子类也是抽象的。

抽象类中的成员特点：
成员变量：成员变量、常量都可以有。
成员方法：可以有成员方法，也可以有抽象方法。
构造方法：有构造方法，但是不能实例化。

接口：
是一种比抽象类更加抽象的“类结构”。
定义的格式：interface 接口名{}
使用格式：class 子类 implements 接口{}  //表示，子类实现了这个接口
注意：
    1.接口可以多实现。
    2.实现接口就必须重写接口中的所有抽象方法。(接口设计的规则：单一规则)
    3.接口中的方法默认访问修饰符是"public abstract"
    4.接口中的常量默认访问修饰符是"public static final"

抽象类和接口的区别
成员变量：
    抽象类，可以有变量，也可以有常量
    接口，只能有常量。
成员方法：
    抽象类：可以有成员方法，也可以有抽象方法
    接口：只能有抽象方法。
构造方法：
    抽象类：有构造函数，但不能创建对象。
    接口：根本就没有构造函数
设计原则：
    抽象类与类之间是继承关系，体现的是"is a"的关系，强调继承。
    接口与类之间是实现关系，体现的是"like a"的关系，强调拥有或包含。

形参和返回值问题
作为形参时：需要传递"抽象类和接口的子类对象"
作为返回值时：返回的是"抽象类和接口的子类对象"
面向接口编程和链式编程(理解)
面向接口编程：尽量使用接口。
链式编程：

——- android培训、java培训、期待与您交流！ ———-