Java程序设计基础------类与对象（三）

这篇博客接着说类和对象中继承和多态的那些事，刚开始接触这个概念的时候，就感觉自己能看得懂，但有时候感觉又不太懂了，希望时间会让我慢慢的成长起来。开始今天的主题吧！

继承和多态的概念不必多说，直接说一说继承中的问题和具体的实例，在实例中找到什么继承和多态的概念。

子类可以继承父类的所有成员吗？

不可以，子类不可以继承父类的私有成员，也就是有private修饰符的。

在子类中可以调用父类的构造方法吗？若可以，如何调用？

 可以，在子类的构造方法中可以调用父类的构造方法，调用方式是在子类的构造方法中的第一行使用super（）调用父类的构造方法。 

静态变量、实例变量、局部变量的声明周期及初始化过程介绍？

静态变量：类的静态变量在内存中只有一个，Java虚拟机在加载类的过程中为静态变量分配内存，静态变量位于方法区，被所有类的实例共享。静态变量可以通过类名访问。静态变量的生命周期取决于类的生命周期。
实例变量：类的每个实例都有相应的实例变量，每创建一个类的实例，Java虚拟机就会为实例变量分配一次内存，实例变量位于堆区中。实例变量的生命周期取决于实例的生命周期。
局部变量：局部变量的生命周期，取决于所属的方法何时被调用及结束调用。当JVM中的某个线程调用一个方法时，会为这个方法中的局部变量分配内存；当JVM中的某个线程结束调用一个方法时，会结束这个方法中的局部变量的生命周期。

在子类中可以访问父类的数据成员吗？

 可以，在子类中可以使用super来访问父类的成员，例如：super.name，super.methods()，但是，父类不能调用private成员。 

父类对象可以访问子类的成员方法吗？

可以，但是，只限于“覆盖”的情况发生，才能通过父类的对象访问子类的方法。

什么是多态机制？形成多态机制的条件是什么？

多态是指在一个程序中同名的多个方法共存的情况。

多态发生的条件是：①要有继承关系  ②要有方法重写  ③父类引用指向子类对象

this和super有何不同？

1>this是指当前的对象，它是一个变量，在实例方法中解决实例变量与局部变量同名的问题。在类的构造方法中，通过this语句调用这个类的另一个构造方法；
2>Super：如果父类中没有提供无参数的构造方法，那么，我们必须通过super语句指导子类调用父类中的其他构造方法；
3>当子类中的局部变量或成员变量与父类中的成员变量同名时，通过super访问父类的成员变量；
4>当子类中的方法重写了父类中的方法并还需要调用父类中被重写的方法时，通过super访问父类中被重写的方法；5>super与this语句出现在构造方法中必须放在构造方法的第一行，并且不能同时出现；
6>super与this关键字不能出现在类方法、类代码快中；

继承的实例代码，以及要注意的事项：

class Father{
    private String name;
    private int age;

    public Father(){
        System.out.println("我是父类的空参构造");
    }  //空参构造  如果没有这个空参构造，那么在子类就不能用空参构造

    public Father(String name,int age){   //有参构造
        
        System.out.println("我是父类的实参构造");
        this.name = name;
        this.age = age;
    }
    public void speak(){
        System.out.println("我是父类的方法");
    }
}
class Son extends Father{

    public Son(){
        //默认会执行super（），但是如果此时父类中没有空参构造，就会报错
    }
    public Son(String name,int age){
        super(name,age);//子类中给出了super（namne,age）方法，就不会执行默认的super（）方法了
    }
}

测试类;

public class extend_demo {
    public static void main(String[] args) {
        Son s = new Son("yanzhiguo ",23);
        //在运行这句话的时候，首先调用Son的构造方法，在执行子类的构造方法之前
        //必须执行父类的构造方法，其目的是为了完成父类成员的初始化操作。
//        System.out.println(s.name);//不能调用父类的私有方法。
        s.speak();
        System.out.println("------------------");
        Son s1 = new Son();
        s1.speak();
    }
}

注意点:

一：上面的注释很重要

二：调用父类的构造方法必须写在子类构造方法的第一行

三：super一定要在构造方法得第一行，且只能出现其中一个

四：this和Super不能在static环境中使用

五：super方法也可以重载，super会根据相应得参数个数，参数类型，参数顺序来执行相应的super方法

 多态的实例代码以及要注意的事项：

class Father1{
    private String name;
    private int age;
    public int i = 123;
    
    public Father1(){}

     public Father1(String name,int age){
         this.name = name;
         this.age = age;
     }
     public void speak(){
         System.out.println("我是父类");
     }
}

class Son1 extends Father1{
    int i = 456;

    public Son1(){
    }

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

    @Override
    public void speak() {
        System.out.println("我是子类");
    }
}

测试类：

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

        Father1 f = new Son1("yan",18);
        System.out.println(f.i);//输出123，不是456
        f.speak();//打印我是子类

    }
}

注意点：

一：对于成员变量，编译看左边，运行看左边，就是看父类中的成员变量。

二：对于成员方法，编译看左边，运行看右边，意思是执行子类中的重写的方法，如果一个方法，父类存在，子类不存在，则执行父类的方法。

三：对于静态方法，编译看左边，运行看左边。

四：父类引用指向子类对象  Father1  f  =  new Son1()；这就是向上转型。

五：Son1 s =（Son1）f；这就是向下转型。

多态的常用方式举例：

package demo_practice;

public class Duotai_exam {
    public static void main(String[] args) {
        methods(new Cat());
        methods(new Dog());
        methods(new Animal());
        System.out.println("----------");
        Animal a =  new Cat();
        a.eat();
      //  a.catMouse(); 不能使用这个方法
        Cat c = (Cat)a;//可以向下转型，然后使用
        c.catMouse();

    }
    public static void methods(Animal a){
        if (a instanceof Cat){
            Cat c = (Cat)a;
            c.eat();
            c.catMouse();
        }
        else if (a instanceof Dog){
            Dog d = (Dog)a;
            d.eat();
            d.lookHome();
        }
        else {
            a.eat();
        }

    }
}
class Animal{
    public void eat(){
        System.out.println("我会吃");
    }
}

class Cat extends Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void catMouse(){
        System.out.println("我会抓老鼠");
    }
}

class Dog  extends Animal{
    public void eat(){
        System.out.println("狗吃肉");
    }
    public void lookHome(){
        System.out.println("我会看家");
    }
}

这就是多态的具体使用方法，可以刚开始不容易理解，但是我相信我会懂得！

  这次的博客就到这了，有兴趣的小伙伴可以一起学习啊！！