Java基础--继承、构造器、重载重写

一、继承

        1、继承的概念

        继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。
        多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。多个类可以称为子类，单独这个类称为父类、超类或者基类。子类可以直接访问父类中的非私有的属性和行为。通过extends关键字让类与类之间产生继承关系。

        2、继承举例（子类extends父类）

        创建person    创建student类继承person类

public class Person {
    public Double height;
    public String name;
    public void run(){
        System.out.println("run");    
    }
    public void a(){
        System.out.println("aaaa");    
    }
}

public class student extends Person{
    public void study(){
        System.out.println("study");    
    }
}

public class Test  {
    public static void main(String[] args){
        Student student = new Student();
        student.run();
        student.a();
        student.study();
        student.height = 180.0;
        
        Person person = new Person();
        person.study();   //这一行报错，父类不能用子类的方法
    }
} 

        继承的本质就是代码的复用，子类可以使用父类的代码，而子类是不能调用父类的代码。

        3、继承特点：

1、不能互相继承（a继承b，b继承a，不对！）；

2、一个类可以被多个类当父亲（一个父类可以有多个子类），但是一个子类只能有一个父类（父亲唯一），（java仅支持单继承）

补充：修饰符比较

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

二、构造器

        1、普通方法

1.方法是有访问权限的

2.方法必须写上返回数据的类型，如果不需要返回数据就写void

        方法创建

void study(){
        System.out.println("study"); 
        return;   
   }  
private int age(){
    return 18;
}       

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

4.方法上可以使用其他的关键字进行修饰，比如static利final,它们有不同的意义。

举例：

public class student{
    public void study(){
        System.out.println("study");    
    }            //合理
    public void study(int age){
        System.out.println("study");    
    }            //合理
    public void study(String age){
        System.out.println("study");    
    }           //合理，类型不同
    public void study(int name){
        System.out.println("study");    
    }           //不合理，与第二个发生冲突，都为int类型
}

       

         2、构造函数（构造器）（创建对象时给对象的变量赋初始值）

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

举例

public class A {
    public Double height;
    public int age;
    public String name;
    public A(String name){
        this.name = name;    
    }                      //自己写的构造器
    public A(String name，int age){
        this.name = name;
        this.age = age;    //自己写的构造器
    } 
}

public class B {
    public static void main(String[] args){
        A a = new A();   //如果是默认无参构造器这样写是对的
        A a = new A("张三")； //自己设置了构造器后   
    }
}

三、重载与重写

        1、重载（在同一个类当中方法名相同但是参数列表不同）

        重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。最常用的地方就是构造器的重载。

public class a{
    public void study(int age){   
    }            
    public void study(String age){   
    }           
    public void study(int name){   
    } 
}     

         2、重写（发生在父子类中，子类重新实现父类的方法功能。）

        在复用的过程中父类方法的实现不一定适用于子类，此时需要用到重写。
        重写（Override）是指子类定义了一个与其父类中具有相同名称、参数列表和返回类型的方法，并且子类方法的实现覆盖了父类方法的实现。 即外壳不变，核心重写！

        举例：

public class A{
    public void run(){ 
        System.out.println("axuexi");  
    }            
}  

public class B extends A{
    public void run(){ 
        System.out.println("bxuexi");  
    }            
}  

public class text {
    public static void main(String[] args){
       B b = new B();
       b.run();      //此时为bxuexi  
    }
}

运行过程如下：
        扫描找main方法，Test.java编译为Test.class进入方法区，main方法入栈。在扫描b，发现b的父类为a，在扫描a（a无父类），将a编译进入方法区，在将b编译调入。
        new生成子类b对象时要先生成父类a对象。子类对父类的run方法重写，调用时优先调用自身重写后的run方法。