大数据学习20190327

抽象类，接口及匿名对象

抽象类

abstract关键字：修饰方法和类

抽象方法：不同类的方法相似，但是具体实现有不尽相同，所以我们只能抽取方法的声明，没有及具体的方法体，没有具体方法体的方法就是抽象方法。

抽象类：有抽象方法的类必须是抽象类。

注意：一个类继承了抽象类需要重写它所有的抽象方法，否则子类就得是抽象类，非抽象方法子类可以不重写。

抽象类的特点：

-抽象方法只能在抽象类里面；

-抽象类和抽象方法必须被abstract修饰；

-抽象类不能创建对象（不能实例化）；

-抽象类中可以有非抽象方法，子类可以不必重写非抽象方法；

-抽象类和类的关系也是继承，

-一个类继承了抽象方法，要么重写抽象类的所有抽象方法，要么他自己也是抽象类。

package com.nike.demo01;

public class AbstractTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        cat.eat();
        dog.eat();

    }
}

abstract class Animal {
    public abstract void eat();

    public void run() {
    }
}

class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");

    }

}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");

    }

}

抽象类

final：修饰成员变量，成员方法，类：

-修饰的类不能被继承；

-修饰的成员方法不能被重写；

-修饰的成员变量是常量，不能修改。

常量：

字面值常量：1，2，3

自定义常量：被final所修饰的成员变量，一旦初始化则不可修改。

注意：自定义常量必须初始化，可以显式初始化或者构造初始化。

抽象类的成员特点：

成员变量：可以有成员变量，常量；

成员方法：可以有抽象方法和非抽象方法；

构造方法：可以有构造方法，作用：给成员变量初始化

public class AbstractTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();
        cat.eat();
        dog.eat();
        dog.barking();

    }
}

abstract class Animal {
    String name = "旺财";
    final int num = 2;
    
    
    public Animal() {
        
    }
    
    

    public Animal(String name) {
        super();
        this.name = name;
    }

    public abstract void eat();

    public void run() {
    }
}

class Cat extends Animal {

    @Override
    public void eat() {
        System.out.println("猫吃鱼");

    }

}

class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");

    }
    
    public void barking(){
        
        System.out.println(name);
        System.out.println(num);
    }

}

View Code

抽象类的细节

抽象关键字abstract不能和哪些关键字共存？

1.final：被final修饰的成员方法不能被重写，final所修饰的类不能被继承。

2.private:父类中被private修饰的方法不能被重写。

抽象类可以没有抽象方法。 

接口

Java语言的继承是单一继承，一个子类只能由一个父类。

Java语言给我们提供了一种机制，用于处理继承单一的局限性，接口。

接口，是一个比抽象类还抽象的类，接口里的所有方法都是抽象方法。

接口和类的关系不再是继承，而是实现（implements）。

创建接口的格式：

interface 接口名{}

接口的成员特点：

只能有抽象方法，接口不能创建对象（不能实例化），

一个类实现一个接口，要么实现这个接口的所有方法，要么这个类是抽象类。

接口中默认只能使用public abstract修饰所有方法。

建议手动给上public abstract修饰符。

接口中只能有常量，默认使用public static final 修饰成员属性。

public class InterfaceTest {

    public static void main(String[] args) {
        BillGates bg = new BillGates();
        bg.code();
        bg.manage();

    }

}

class BillGates extends Coder implements Boss {

    @Override
    public void manage() {
        System.out.println("管理公司");

    }

}

interface Boss {
    int num = 0;

    public abstract void manage();
}

class Coder {
    public void code() {
        System.out.println("敲代码");
    }
}

View Code

接口与类之间的关系：

类与类：继承关系，单一继承，多层继承。

类与接口：实现关系，多实现。

接口与接口：继承关系，多层继承，多继承。

接口的优点：

一个类可以实现多个接口，打破了继承的局限性。

接口中所有成员都是公共的，对外提供规则，规范。

降低了程序的耦合性，提高开发的效率，（可以实现模块化开发，定义好规则，每个人实现自己的模块）。

抽象类与接口的区别

共性：

1.不断的抽取，抽取出抽象的概念。

区别：

1.与类之间的关系：类与接口是实现关系，多实现；类与抽象类是继承关系，单一继承，多层继承。

2.成员：

-抽象类可以有成员变量，常量；接口只能有常量。

-抽象类可以有抽象方法，也可以有非抽象方法；接口只能有抽象方法，而且方法有默认修饰符（public abstract）

-抽象类有构造方法；接口没有构造方法

public class InterfaceDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        BasketballPlayer bp = new BasketballPlayer();
        bp.sleep();
        bp.learn();
        bp.speak();
        BasketballCoach bc = new BasketballCoach();
        bc.speak();
        
    }

}
class Person{
    String name;
    int age;
    String gender;
    
    public Person() {
        
    }
    public Person(String name, int age, String gender) {
        
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    
    public void eat(){
        System.out.println("吃饭");
    }
    
    public void sleep(){
        System.out.println("睡觉");
    }
    
}

abstract class Player extends Person{
    public abstract void learn();
}

abstract class Coach extends Person{
    public abstract void teach();
}

class BasketballPlayer extends Player implements LearnEnglish{

    @Override
    public void learn() {
        System.out.println("学习扣篮");
        
    }

    @Override
    public void speak() {
        System.out.println("说英语");
        
    }
}

class PingPongPlayer extends Player{

    @Override
    public void learn() {
        System.out.println("学习抽球");
        
    }
    
}

class BasketballCoach extends Coach implements LearnEnglish{

    @Override
    public void teach() {
        System.out.println("教扣篮");
        
    }

    @Override
    public void speak() {
        System.out.println("说英语");
        
    }
    
}
class PingPongCoach extends Coach{
    
    @Override
    public void teach() {
        System.out.println("教抽球");
        
    }
    
}

interface LearnEnglish{
    public abstract void speak();
}

View Code

匿名对象

匿名对象：没有变量引用的变量。

应用场景：当方法只调用一次的时候，可以使用匿名对象。

匿名对象可以调用成员变量，可以赋值，但是没有意义；

可以当作参数传递。