Java零基础day10

• 一、继承
• • 1.Java中继承
  • • 案例
  • 2.关于父类子类的内存分析
• 二、重写（Override）
• • • 案例
• 三、重载（Overload）
• • • 案例

Java 有三大特性: 封装 继承 多态

继承是类和类之间的关系，至少得两个类才可以谈继承

语法格式:

class Son extends Father {
	
}

其中Son是一个类，Father是一个类，Son类继承了Father类。 Son是Father的子类，Father是Son的父类（超类，基类）。

继承的本质：就是将父类的属性和方法拿到子类中去使用。

1.成员变量（属性）

公开的和默认的属性，子类可以继承使用的，私有的成员变量，子类无法使用的。

2.成员方法

公开的和默认的成员方法，子类可以继承使用，​私有的成员方法，子类无法使用的。

总结：凡是私有的成员变量，成员方法无法继承。

3.构造方法

先执行父类的构造方法，再执行子类的构造方法，如果父类中有有参构造，但是没有无参构造，子类就会报错。

​关于构造方法：父类与子类的构造方法的形式保持一致。

父类中有无参构造，子类也有无参构造。父类中没有无参构造，子类也没有无参构造方法。

Animal 类 父类

Dog类 子类

Cat类 子类

代码如下（示例）：

package com.qfedu.a_extends;


public class Animal {
    private String name;
    private int age;
    private char sex;

    public Animal() {
    }

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

    public void eat() {
        System.out.println("吃饭");
    }

    
    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 char getSex() {
        return sex;
    }

    
    public void setSex(char sex) {
        this.sex = sex;
    }
    
}

//Animal类
public class Animal {
    String name;
    int age;
    char sex;

    public void eat(){
        System.out.println("吃饭");
    }
}

//Cat类
public class Cat extends Animal{

}

//Dog类
public class Dog extends Animal{

}

重写目的：子类可以继承父类的非私有化的方法，但是有的时候父类的需求满足不了子类的需求了，这个时候需要重写父类非私有的方法。

​重写要求：

1.必须有继承关系

2.父类的方法必须是非私有化的

3.在子类中重写父类的方法，这个方法除了方法体不一样其他都一样的

4.必须在子类中去重写

代码如下（示例）：

package com.qfedu.b_extends;


public class Music {
    public static void tune(Instrument instrument) {
        instrument.play();
    }

    public static void main(String[] args) {
        Instrument instrument = new Instrument();
        Wind wind = new Wind();
        Brass brass = new Brass();
        tune(instrument);
        tune(wind);
        tune(brass);
        wind.play2();
        brass.play2();
    }
}

//父类：乐器
//Instrument类
//方法 play();
public class Instrument {
    public void play() {
        System.out.println("弹奏乐器");
    }
}

//Brass类
//方法 play()
//方法 play2()
public class Brass extends Instrument {
    @Override
    public void play() {
        System.out.println("弹奏brass");
    }

    public void play2() {
        System.out.println("调用brass的play2");
    }
}

//Wind类:
//方法 play()
//方法 play2()
public class Wind extends Instrument{
    @Override
    public void play() {
        System.out.println("弹奏Wind");
    }
    public void play2(){
        System.out.println("调用Wind的play2");
    }
}

在Java中同一个类中可以有很多个方法，有的方法名字一样，但是参数类型不一样，这一类方法叫重载。

总结：

1.方法的重载必须在同一个类中

2.方法名字必须一致

3.方法的参数类型必须不一样

4.方法的返回值可以不一样

5.无参构造和有参构造，也是一种重载

面试题: 重写和重载的区别

答：方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。

代码如下（示例）：

class Person {
	//方法名字一样，但是参数类型不一样，这一类方法叫重载。
	//返回值可以不一样
	public void test () {
		System.out.println("test");
	}
	public void test (String name) {
		System.out.println(name);
	}
	public void test (int i) {
		System.out.println(i);
	}
	void test (double d1) {
		
	}
	public String test(String str1, String str2) {
		return str1 + str2;
	}
}