Java 学习笔记 day 8 (面向对象4)

抽象类  

抽象方法是一种特殊的方法：它只有声明，而没有具体的实现.

抽象方法必须用abstract关键字进行修饰.

抽象类除了不能创建对象外,类的其他功能都正常(成员变量,成员方法,构造方法)
抽象类位于类结构的上层
静态方法不能被修饰为抽象方法
一个类可以有多个抽象方法

public abstract class Animal {
    private  String name;
    private  int age;

    public  Animal(){

    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void eat();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Dog extends Animal{

    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }
}
public class TsetAnimal {
    public static void main(String[] args) {
        new Dog();
    }
}

多态

父类引用指向子类对象，从而产生多种形态

Animal dog = new Dog();

Animal cat = new Cat();

同一种事物，在不同时刻表现不同状态

二者存在直接或者间接的继承关系时，父类引用指向子类的对象，即

形成多态。

public abstract class Animal {
    private String  name;
    private int age;
    int num=18;

    public abstract void eat();

    public void sleep(){
        System.out.println("动物睡觉");
    }

    public static void show(){
        System.out.println("animal中的show()");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public class Cat extends Animal{
    @Override
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}
public  class Dog extends Animal{
    int num=20;
    @Override
    public void eat(){
        System.out.println("狗吃骨头");
    }

    public static void show(){
        System.out.println("dog中的show()");
    }
    public void lookhome(){
        System.out.println("狗可看家");
    }
}
public class Person {
    //定义一个方法,处理不同子类,提高程序扩展性
    public void feed(Animal animal){
        animal.eat();

        //判断animal变量,实际运行时表示的是否是Dog类型
        if(animal instanceof Dog){
            Dog dog=(Dog)animal;
            dog.lookhome();
        }
        if(animal instanceof Cat){
            Cat cat=(Cat)animal;
            cat.catchMouse();
        }
    }
}
public class Test {
    public static void main(String[] args) {

        /*
        多态----多种状态
        同一个父类,可以表示不同的子类对象,状态就不同了

        父类的引用指向子类的对象,两个类之间必须是继承关系
        把子类的类型转为父类的类型,同一个父类在不同时候,表示不同状态
         */
        Animal dog=new Dog();
        Animal cat=new Cat();
        Person person=new Person();
               person.feed(dog);
               person.feed(cat);
    }
}
public class Test1 {
    public static void main(String[] args) {
        /*
        多态注意事项:
            注意成员调用时,分为编译期间与运行期间
            编译期间:写代码时,由于类型上升为父类类型,所以只能调用父类中定义成员
            运行期间:运行代码时,实际调用的是子类中重写的方法

            对于非静态成员方法:
                  编译看左边,运行看右边
            对于静态成员方法,成员变量:
                  编译运行都看左边
         */

        Animal dog=new Dog();
        Animal cat=new Cat();

        dog.eat();
        cat.eat();

        dog.sleep();  //对于子类如果没有父类中的方法,那么调用的是子类对象中父类中的方法
        cat.sleep();

        dog.show();
        System.out.println(dog.num);
    }
}
public class Test2 {
    public static void main(String[] args) {
        Animal dog=new Dog();
        Animal cat=new Cat();
        /*
        多态在某种情况下的缺点:
              为了实现多态性, 将子类类型向上转为了父类类型,
              但是一旦类型上升为父类类型就调用不到子类中特有的方法.

              解决办法:
                   向下转型,把父类类型转为子类类型
         */
        Dog d= (Dog)dog;
        d.lookhome();
        Person p=new Person();
        p.feed(dog);
        p.feed(cat);
        p.feed(dog);
        p.feed(cat);
    }
}

final关键字

/*
final关键字,可以修饰类,方法,参数,成员变量
final不能定义类和接口,因为final修饰的类不能被继承
final修饰方法,修饰后方法不能被子类重写
final修饰方法的参数,在方法内部,不能修改参数值
final修饰成员变量,
 */
public class Demo {
    //情况1:在编码时,值就确定了,直接进行赋值,此种情况加上static,让其在内存中只有一份
    static final int num=10;

    //情况2:每一个对象中都有一个常量,必须在构造方法中为常量进行初始化,一旦初始化,值都不能更改
    final int count;

    public Demo(int count) {
        this.count = count;
    }

    public final void test(final int a){
       // a=10;
    }

    public static void main(String[] args) {
       /* Demo demo=new Demo();
        demo.test(20);*/
        new Demo(10);
    }
}

接口

/*
         接口:
             是一种更为彻底的抽象,主要用来定义功能
             接口不能被创建对象

             jdk8之后接口可以定义4种内容
                1.静态常量
                2.抽象方法
                3.静态方法(jdk8之后才开始有)
                4.默认方法(jdk8之后才开始有)
 */
public interface Myinterface {
    int num=10;   //public static final int num = 10   静态常量
    void test();  //public abstract void test();  抽象方法

    //接口中定义静态方法,通过接口名直接访问
    public static void staticMethod(){

    }
    //默认方法,需要类继承,通过子类调用
    public default void test1(){

    }
}
/*
类实现接口类,一个类可以实现多个接口
就是Myinterface接口的实现类MyinterfaceImpl
 */
public class MyinterfaceImpl implements Myinterface{

    @Override
    public void test(){

    }

    public static void main(String[] args) {

    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println(Myinterface.num);
        Myinterface.staticMethod();

    }
}

public abstract class Animal {
    private String name;
    private int age;

    public abstract void eat();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class Bird extends Animal implements Fly{

    @Override
    public void eat() {

    }

    @Override
    public void fly() {

    }
}
public class Dog extends Animal implements Run{

    private String type;

    @Override
    public void eat() {

    }

    @Override
    public void run() {

    }
}
public class Fish extends Animal implements Swim,Fly{

    @Override
    public void eat() {

    }

    @Override
    public void swim() {

    }

    @Override
    public void fly() {

    }
}
public interface Fly {

    void fly();
}
public interface Run {

    void run();
}
public interface Swim {
    void swim();
}
public class Test {
    public static void main(String[] args) {
        Animal animal=new Dog();
        Animal animal1=new Bird();
        Animal animal2=new Fish();


        /*
        接口和实现类之间也是可以有多态关系
        用一个接口表示一类拥有此功能的类
         */

        Fly fly=new Bird();
        Fly fly1=new Fish();
        Run run=new Dog();
        Swim swim=new Fish();
    }
}