Java入门篇 之 继承

本篇碎碎念：最近的课程遇到瓶颈了，看的时候感觉自己会了，但是结束仔细一回顾还是一知半解，一点一点来吧，基础必须要打好(自己给自己好的心里暗示，结局一定是好的)

今日份励志文案:慢慢改变，慢慢成长，慢慢适应，慢慢优秀

冲冲冲！！！！

继承

怎么去设计继承，什么时候会用到继承

继承解决了什么问题？？？

继承是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类叫做派生类（子类）

继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程

继承主要解决的问题是:共性的抽取，实现代码复用。

例如：猫和狗都是动物，我们就可以将共性的内容进行抽取，然后采用继承的思想来达到共用

如果不使用继承，代码变得比较麻烦，看下列代码

代码的简单演示

class Bird{
    public String name;
    public int age;
    public void fly(){
        System.out.println(this.name+"正在天上飞");
    }
    public void print(){
        System.out.println("这只鸟的名字是："+this.name+
                ",它已经"+this.age+"岁了");
    }
}
class Fish{
    public String name;
    public int age;
    public void swim(){
        System.out.println(this.name+"正在水里游泳");
    }
    public void print(){
        System.out.println("这条鱼的名字是："+this.name+
                ",它已经"+this.age+"岁了");
    }
}

    public static void main(String[] agrs){
        Bird bird=new Bird();
        Fish fish=new Fish();

        bird.age=1;
        bird.name="鹦鹉";
        bird.fly();
        bird.print();

        fish.age=2;
        fish.name="锦鲤";
        fish.swim();
        fish.print();
    }

其中：

public String name;
public int age;

为重复代码

此时就可以使用继承的概念来修改这段代码 

class Animal1{
    public String name;
    public int age;

}
class Bird extends Animal1{

    public void fly(){
        System.out.println(this.name+"正在天上飞");
    }
    public void print(){
        System.out.println("这只鸟的名字是："+this.name+
                ",它已经"+this.age+"岁了");
    }
}
class Fish extends Animal1{
    public void swim(){
        System.out.println(this.name+"正在水里游泳");
    }
    public void print(){
        System.out.println("这条鱼的名字是："+this.name+
                ",它已经"+this.age+"岁了");
    }
}

其中extend 是Java语言中的一个关键字

 使用方式为:

子类 extends 父类

---

class A{
    public int a=1;
    public int b=2;
}
class B extends A{
    public int a=10;
    public int c=3;
public void print1(){
    System.out.println(a);
    System.out.println(b);
    System.out.println(c);
    }
}

根据就近原则:优先访问子类的，如果子类没有a，就访问父类的 

可以根据super关键字去指定告诉编译器，我们访问的父类的a

以上述代码举例，用法是 ：System.out.println(super.a);

1.2 super和this的区别是什么? 

相同点：

1.都是Java中的关键字

2.只能在类的非静态方法中使用，用来访问非静态成员方法和字段

字段的讲解:字段（也可以称作数据成员）可以是任何类型的对象，可以通过其引用与其进行通信，也可以是基本类型的一种

3.在构造方法中调用时，必须是构造方法中的第一条语句，并且二者不可以同时存在

不同点：

1.this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用

2.在非静态成员方法中,this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性

3.在构造方法中:this(...)用于调用本类构造方法，super(...)用于调用父类构造方法，两种调用不能同时在构造方法中出现

4.构造方法中一定会存在super(...)的调用，用户没有写编译器也会增加，但是this(...)用户不写则没有

在子类方法中 或或者 通过子类对象访问成员时:

1.如果访问的成员变量子类中有，优先访问自己的成员变量

2.如果访问的成员变量与父类中成员变量同名，则优先访问自己的

class A{
    public void fun(){
        System.out.println("父类中的");
    }
}
class B extends A {
    public void fun() {
        System.out.println("子类中的");
    }

    public void test() {
        fun();
    }
}


//底下是书写main函数中的


  public static void main(String[] args) {
        B b=new B();
        b.test();
}

 

3.如果访问的成员变量子类中无，则访问父类继承下来的，通过父类有没有定义，则报错 

class A {
    public void fun() {
        System.out.println("父类中的");
    }
}
class B extends A {
    public void test() {
        fun();
    }
}

下列代码中：同问fun函数，由于子类中含有参数 a，fun（10）访问的是子类中的 fun 

若父类中fun含有参数，同子类一样

class A{
    public void fun(){
        System.out.println("父类中的");
    }
}
class B extends A {
    public void fun(int a) {
        System.out.println("子类中的"+a);
    }

    public void test() {
        fun(10);
    }
}

---

产生子类对象的时候，父类的成员就要初始化好

class Animal {
    public String name;
    public String color;

    //当没有public Animal 
    //Java会提供一个
    //所以没有public Animal才不报错，最好还是写上
    public Animal(String name, String color) {
        this.name = name;
        this.color = color;
    }
    public void eat() {
        System.out.println(this.name + "正在吃...");
    }

}

class Cat extends Animal {

    public String character;

    //可以没有String name, String color
    //可以在super中体现
    //传了参数会更灵活
    public Cat( String color,String name ,String character ) {
        //调用父类的带有子类的2个参数的构造方法来初始化父类成员
        super(name,color);
        this.character=character;
    }
    public void print(){
        System.out.println("这只猫的名字是："+name+
                ",它的毛是"+color+",它是"+character);
    }
    public void barks() {
        System.out.println(this.name + "正在叫...");
    }

}

class Dog extends Animal {
    public float weight;

    public Dog(String name, String color, float weight) {
        super(name, color);
        this.weight = weight;
    }

    public void wangwang() {
        System.out.println(this.name + "超重了！！！");
    }
}

public static void main(String[] args) {
        Cat cat = new Cat("白棕色","布偶猫","可爱的");
        cat.eat();
        cat.print();
        Dog dog = new Dog("边牧犬","白黑色",60);
        dog.wangwang();
    }

上述例子，实例化了父类成员，在子类中调用了

上面这个图片是我刚开始写代码时犯的错误：

1. cat.name= 是没有括号的，直接写就行
2. cat.name   在eat上面调用，要不然就是null（ps：都运行结束了，再赋值，能运行出来才怪）

补:什么是实例化对象?

Java实例化就是使用new关键字创建一个对象的过程

例如：

Animal cat = new Animal

new Animal是以Animal类为模板，在堆空间创建类一个Animal类的对象

( ) 括号代表在对象创建后，立即调用Animal类的构造函数，对刚生成的对象初始化

Animal cat 创建了一个Animal类的引用变量

代码块的运行顺序（具体运行代码会在下一条博客说明）

1、父类静态代码块优先于子类静态代码块执行，且是最早执行

2、父类实例代码块和父类构造方法紧接着执行

3、子类的实例代码块和子类构造方法紧接着再执行

4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行（也就是说静态代码块只执行一次）

如果有解释的不对或者不清晰，如果可以从评论区指出，我一定会加以修改，万分感谢

希望对你们有所帮助