Java基础疑点解析 1、多态 、抽象类和接口 2、成员变量与局部变量的区别

一、多态 、抽象类和接口
1、多态
1.1多态的概述
什么是多态？
同一个对象，在不同时刻表现出来的不同形态
多态的前提
1、要有继承或实现关系
2、要有方法的重写
3、要有父类引用指向子类对象
1.2、多态中的成员访问特点
成员变量
编译看父类，运行看父类
成员方法
编译看父类，运行看子类

public class Animal {

    public int age = 40;

    public void eat() {
        System.out.println("动物吃东西");
    }   
}

public class Cat extends Animal {

    public int age = 20;
    public int weight = 10;

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

    public void playGame() {
        System.out.println("猫捉迷藏");
    }

}

public class AnimalDemo {
    public static void main(String[] args) {
        //有父类引用指向子类对象
        Animal a = new Cat();

        System.out.println(a.age);
//        System.out.println(a.weight);

        a.eat();
//        a.playGame();

    }
}

运行结果：
40
猫吃鱼
1.3、多态的好处和弊端
好处
提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
弊端
不能使用子类的特有成员
1.4、多态中的转型（应用）
向上转型
父类引用指向子类对象就是向上转型
向下转型
格式：子类型 对象名 = (子类型)父类引用;

public class Animal {
	public void eat() {
		System.out.println("动物吃东西");
	}
}

public class Cat extends Animal {
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	public void playGame() {
		System.out.println("猫捉迷藏");
	}
}

public class AnimalDemo {
	public static void main(String[] args) {
		//多态
		//向上转型
		Animal a = new Cat();
		a.eat();
		// a.playGame();
		//向下转型
		Cat c = (Cat)a;
		c.eat();
		c.playGame();
	}
}
		

2.抽象类
2.1、抽象类的概述
当我们在做子类共性功能抽取时，有些方法在父类中并没有具体的体现，这个时候就需要抽象类了！
在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！
2.2抽象类的特点
1、抽象类和抽象方法必须使用 abstract 关键字修饰

//抽象类的定义
public abstract class 类名 {}
//抽象方法的定义
public abstract void eat();

2、抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
3、抽象类不能实例化
抽象类如何实例化呢？参照多态的方式，通过子类对象实例化，这叫抽象类多态
4、抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类
2.3、抽象类的成员特点
成员的特点
成员变量
既可以是变量
也可以是常量
构造方法
无参构造
有参构造
成员方法
抽象方法
普通方法

/*
    抽象类
 */
public abstract class Animal {

    private int age = 20;
    private final String city = "北京";

    public Animal() {}

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


    public void show() {
        age = 40;
        System.out.println(age);
//        city = "上海";
        System.out.println(city);
    }

    public abstract void eat();

}

public class Cat extends Animal {

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

public class Cat extends Animal {

    public int age = 20;
    public int weight = 10;

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

    public void playGame() {
        System.out.println("猫捉迷藏");
    }
}

3、接口
3.1接口的概述
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中的接口更多的体现在对行为的抽象！
3.2接口的特点
1、接口用关键字interface修饰
2、类实现接口用implements关键字表示

public interface 接口名 {}

public class 类名 implements 接口名 {}

3、接口不能实例化
接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态。
多态的形式：具体类多态，抽象类多态，接口多态。
4、接口的子类
要么重写接口中的所有抽象方法
要么子类也是抽象类

3.3、接口的成员特点
成员特点
成员变量
只能是常量 默认修饰符：public static final
构造方法
没有，因为接口主要是扩展功能的，而没有具体存在
成员方法
只能是抽象方法
默认修饰符：public 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 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 abstract void eat();
}
接口
public interface Jumpping {
    public abstract void jump();
}
猫类
public class Cat extends Animal implements Jumpping {

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

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

    @Override
    public void jump() {
        System.out.println("猫可以跳高了");
    }
}
测试类
public class AnimalDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Jumpping j = new Cat();
        j.jump();
        System.out.println("--------");

        Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
//        a.jump();

        a = new Cat("加菲",5);
        System.out.println(a.getName()+","+a.getAge());
        a.eat();
        System.out.println("--------");

        Cat c = new Cat();
        c.setName("加菲");
        c.setAge(5);
        System.out.println(c.getName()+","+c.getAge());
        c.eat();
        c.jump();
    }
}

运行结果：
猫可以跳高了
--------
加菲,5
猫吃鱼
加菲,5
猫吃鱼
--------
加菲,5
猫吃鱼
猫可以跳高了

3.4、类和接口的关系
类与类的关系
继承关系，只能单继承，但是可以多层继承
类与接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
接口与接口的关系
继承关系，可以单继承，也可以多继承
3.5抽象类和接口的区别
成员区别
抽象类
变量,常量；有构造方法；有抽象方法,也有非抽象方法
接口
常量；抽象方法
关系区别
类与类
继承，单继承
类与接口
实现，可以单实现，也可以多实现
接口与接口
继承，单继承，多继承
设计理念区别
抽象类
对类抽象，包括属性、行为
接口
对行为抽象，主要是行为
补充：
这个问题，要分JDK版本来区分回答：
JDK1.8之前：
语法：
抽象类：方法可以有抽象的，也可以有非抽象, 有构造器
接口：方法都是抽象，属性都是常量，默认有public static final修饰
设计：
抽象类：同一类事物的抽取，比如针对Dao层操作的封装，如，BaseDao，BaseServiceImpl
接口：通常更像是一种标准的制定，定制系统之间对接的标准
例子：
1，单体项目，分层开发，interface作为各层之间的纽带，在controller中注入IUserService，在Service注入IUserDao
2，分布式项目，面向服务的开发，抽取服务service，这个时候，就会产生服务的提供者和服务的消费者两个角色
这两个角色之间的纽带，依然是接口
JDK1.8之后：
接口里面可以有实现的方法，注意要在方法的声明上加上default或者static
最后区分几个概念：
多继承，多重继承，多实现
多重继承：A->B->C（爷孙三代的关系）
多实现：Person implements IRunable,IEatable（符合多项国际化标准）
多继承：接口可以多继承，类只支持单继承

二、成员变量与局部变量的区别
类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
内存中位置不同：成员变量（堆内存）局部变量（栈内存）
生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，随着方法的调用完毕而消失）
初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

参考资料：
https://zhuanlan.zhihu.com/p/58181076
https://www.bilibili.com/video/BV18J411W7cE?from=search&seid=15690035677565271828
黑马程序员笔记