java的继承、重载和重写

一.java的继承

如何继承？
格式：子类 extends 父类
例如：

1.父类

public class Person {
    public Double height;
    public String name;
    public char sex;

    public void run() {
        System.out.println("任何人都可以跑");
    }
    public  void a() {
        System.out.println("...");
    }
}

2.子类

public class Student extends Person {

}

3.测试

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.run();
        student.a();
        student.height = 180.0;
        //继承的本质就是代码的复用:是子类复用父类的代码，父类是用不了子类的代码的!
        Person person = new Person();
    }
}

总结：
继承的本质就是代码的复用，子类可以使用父类已经写好的代码，如此子类就无需重新编写此类代码了。子类可以调用所继承父类的代码，而父类无法调用子类的代码。

4.java的继承层次

总结：
子类和父类不能互相继承
一个父类可以有多个子类
一个子类只能有一个父类

二.重载和重写

1.java修饰符

总结：
public修饰的代码，本类和其他类都是可以访问的
private修饰的代码，本类是可以访问的,但是其他类不可以访问

2.java普通方法

什么是方法？
(1）方法是有访问权限的(public 公共的、protected受保护的、不写（(注意是子类但是不同包也是不可以访问的)、private私有的)
(2）方法必须写上返回数据的类型，而且return返回的数据必须是该类型。如果不需要返回数据就写void在代码中直接写一个return就行。
例:

	private int age() {
   		return 18;
    }

    void study(){
    	System.out.println("123");
    	return;
    }

(3）在同一个类中，方法名可以相同但方法的签名不能相同(方法签名=方法名+参数列表的类型)
例:

	void study(int name){
		System.out.println( "111");
		return;
}

	void study (String name){
		Systea.out.println( "111");
		return;
}

(4）方法名可以使用其他的关键字进行修饰，比如static和final，他们有着不同的意义。
java的修饰符(public 公共的、protected受保护的、不写（注意是子类但是不同包也是不可以访问的)、private私有的)

3.方法重载

方法的重载，发生在本类当中，在同一个类当中方法名相同但是参数列表不同，就是方法的重载。
例如：

void study(int age){
	Systeam.out.println( "111");
	return;
}

void study(String name){
	Systeam.out.println( "111");
	return;
}

4.方法重写

为什么会有重写？
继承的本质是代码的复用，在复用的过程当中父类的方法的实现不一定完全方法重写之后，子类对象调用的也是重写后的方法
方法的重写:发生在父子类当中，子类重新实现父类方法的功能
！重写前：
A：

public class A{
	public void run(){
	system.out.println("A跑的很快");
	}
}

B：

public class B extends A{
	public void run(){
	}
}

Test：

public class Test {
	public static void main(String[] args) {
	Bb = new B();
	b.run();
	}
}

输出结果：

！重写后：
A：

public class A{
	public void run(){
	system.out.println("A跑的很快");
	}
}

B：

public class B extends A{
	public void run(){
	System.out.println("B跑的很快");
	}
}

Test：

public class Test {
	public static void main(String[] args) {
	Bb = new B();
	b.run();
	}
}

5.构造函数（构造器）

作用：
在创建对象的时候给对象的额变量赋值

特点：
1.在类当中构造函数必须和类名相同
2.在类当中有一个默认的不显示的无参数的构造器，一旦你在类当中写一个构造器，那么那个无参构造器就会被覆盖
3.构造器不需要写返回类型
4.一个类当中可以有多个构造函数

6.例：

重写前：
A：

public class A{
    public void run(){
        System.out.println("A跑的很快");
    }
    public void flay(){
        System.out.println("飞得很高");
    }
}

B：

public class B extends A{
    
}

Test：

public class Test {
    public static void main(String[] args) {
        B b=new B();
        b.run();
        b.flay();
    }
}

输出结果：

![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/e398734d046c49799cef670c8038159b.png

这里的B b=new B();调用B中的无参构造器，B再继续调用A的，所以创建B对象的时候会优先创建A的对象

重写后：
A：

public class A{
    public void run(){
        System.out.println("A跑的很快");
    }
    public void flay(){
        System.out.println("飞得很高");
    }
}

B：

public class B extends A{
    public void run(){
        System.out.println("B跑的很快");
    }
}

Test：

public class Test {
    public static void main(String[] args) {
        B b=new B();
        b.run();
        b.flay();
    }
}

输出结果：


这里在B中子类重写了父类的方法，父类的方法会被覆盖掉

再次重写：
A：

public class A{
    public void run(){
        System.out.println("A跑的很快");
    }
    public void flay(){
        System.out.println("飞得很高");
    }
}

B：

public class B extends A{
    public void run(){
        System.out.println("B跑的很快");
    }
}

Test：

public class Test {
    public static void main(String[] args) {
        B b=new B();
        b.run();
        b.flay();
 
        A a=new A();
        a.run();
    }
}

输出结果：


这里在Test又A a=new A();new关键字是在堆内存中开辟一个新的内存空间