Java基础——继承，构造器，重载重写

目录

一. 继承

person类(父类)student

 student类(子类)

 测试类

 总结

 三.方法

（1）各修饰符的访问权限

（2）普通方法

 五.构造器

(1)构造器的特点

（2）作用

 六.方法的重载和重写

重载：

重写：

 例题：

执行流程

代码输出的原因

子类

 父类

 main方法

---

---

一. 继承

person类(父类)student

public class Person {
    
    public Double height;
    public String name;
    public char sex;
    
    public void run(){
        System.out.println("任何人都可以跑");
    }
    public void a(){
        System.out.println(".........");
    }
   
}

 student类(子类)

public class Student extends Person{


}

 测试类

public class Person {
    public static void main(String[] args) {
        Student student = new Student();
        student.run();
        student.a();
        student.study();
        student.height = 180.0;
    }
}

继承的本质就是代码的复用，是子类复用父类的代码，父类无法使用子类的代码。

 总结

java的继承层次当中是不能互相继承的

一个类可以被多个类当作父类，一个子类只能用一个父类（java仅支持单继承）

 三.方法

（1）各修饰符的访问权限

	本类	子类	同包	不同包
public	可以访问	可以访问	可以访问	可以访问
protected	可以访问	可以访问	可以访问	无法访问
不写	可以访问	可以访问	可以访问	无法访问
private	可以访问	无法访问	无法访问	无法访问

public修饰的代码，本类和其它类都是可以访问的。private修饰的代码，本类是可以访问的，但是其他类不可以访问。

（2）普通方法

方法有访问权限同3

方法必须有返回类型，没有就写void

同一类中方法名可以相同但方法签名不能相同（方法签名=方法名+参数列表形式）

public class A {
    void study(){
        System.out.println("好好学习");
    }
    void study(String name){
        System.out.println("hhxx");
    }
    void study(int age,String aa){
        
    }
    void study(int name){
        System.out.println("好好学习天天向上");
    }
}

 五.构造器

(1)构造器的特点

1.在类当中构造函数必须和类名相同。

2.在类当中有一个默认的不显示的无参数的构造器，一旦你在类当中写一个构造器，那么那个无参构造器就会被覆盖。

3.构造器不需要写返回类型

4.一个类当中可以有多个构造函数

（2）作用

在创建对象时给对象赋值

public class Student {

    public double height;
    public String name;
    public char sex;
    public Student(String name){
        this.name = name;
    }
    public Student(String name,char sex){
        this.name = name;
        this.sex = sex;
    }
    public void run(){
        System.out.println("run");
    }
    public void a(){
        System.out.println("a");
    }
}

相应的，在创建对象时也要传参

 六.方法的重载和重写

重载：

在同一类中，同名方法，但但方法签名不能相同（方法签名=方法名+参数列表形式）重写：在子类中重写父类的方法，重写：在子类中重写父类的方法，

public class A {
   public void study(){
        
    }
   public void study(String name){
        
    }
   public void study(int age,String aa){
        
    }
   
}

重写：

在子类中重写父类的方法， 

父类

public class A {

 public void run(){

     System.out.println("a");

     }
}

 子类

public class B extends A{

    public void run(){

      System.out.println("b");

   }
}

public class Main{

 public static void main(String[] args){

     B b = new B();
     b.run();

      }
}

 

 例题1：

public class Test extends Base{
    public Test(){
        System.out.println("test constructor");
    }
    public static void main(String[] args) {
        new Test();
    }
    static {
        System.out.println("test static");
    }
    
}
 class Base {
    static {
        System.out.println("base static");
    }
    public Base(){
        System.out.println("base constructor");
    }
     
 }

执行流程

代码输出的原因

1.扫描含main方法的Test类发现其有父类则扫描父类Base类，直到没有父类为止。
2.变为Base.class进入方法区，执行static方法。
3.变为Test.class进入方法区，执行static方法。
4.main方法入栈，要创建Test（）对象。
5.发现其有父类先创建父类base对象，执行构造方法输出base constructor。
6.再创建Test类，执行构造方法输出test constructor

方法的重写的执行流程

子类

public class B extends A{

   public void flay(){

     System.out.print("我会飞");
  }
 public void run(){

   System.out.println("B比A跑的快");
 }
}

 父类

public class A{

   public void run(){

   System.out.println("A跑的很快");

}
    private void study(){

     System.out.println("好好学习");

}

 main方法

public class Tset{

   public static void main(String[] args){

     B b = new B();
     b.run();
     b.flay();
  }
}