在java继承中，子类也称为派生类，父类也称为基类或者超类，基本语法 ：子类 extends 父类{}
实现一个简单的继承类：
class Person{
private String name;
private int age;
public void setName(String name){
this.name = name ;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age ;
}
public int getAge(){
return age ;
}
}
class Student extends Person{
private String school ;
public void setSchool(String school){
this.school = school ;
}
public String getSchool(){
return school ;
}
}
public class Test{
public static void main(String args[]){
Student stu = new Student();
stu.setName("小学生");//父类方法
stu.setAge(18);//父类方法
stu.setSchool("蓝翔挖掘机专修学院"); //自身方法
System.out.println(stu.getName()+"、" + stu.getAge() + "、" + stu.getSchool());
}
}
在对子类进行实例化的时候，先是执行父类构造方法，然后执行子类
class Person{
public Person(){
System.out.println("父类无参构造");
}
}
class Student extends Person{
public Student(){
super();//此处不写super();也会默认调用
System.out.println("子类无参构造");
}
}
public class Test{
public static void main(String args[]){
new Student();//此时默认调用父类无参构造
}
}
/*执行结果：
父类无参构造
子类无参构造
*/
class Person{
private String name;
public Person(String name){
System.out.println("父类无参构造" + name);
}
}
class Student extends Person{
public Student(){
super("java");//调用父类的有参构造，一定要放在第一个语句，和this()相似
System.out.println("子类无参构造");
}
}
public class Test{
public static void main(String args[]){
new Student();//此时默认调用父类无参构造
}
}
/*执行结果：
父类无参构造
子类无参构造
*/
子类覆写父类的方法中的注意点
实例化的是哪一个类，在实例化对象在调用的时候就会默认调用该类的方法，如果子类不存在该方法，则会调用父类中的该方法，
子类在覆写父类中的方法时候，方法的访问权限不能比父类要高，如果父类使用了private定义了一个方法，那么子类无法覆写，因为private定义的方法对外不可见只可以在本类中使用，即使子类写了一个相同的方法，也不可以称为覆写
class A{
public void print(){
System.out.println("A类中的方法");
}
public void fun(){
System.out.println("B类没有覆写该方法，默认调用父类");
}
}
class B extends A{
public void print(){
System.out.println("B类中的方法");
}
}
public class Test{
public static void main(String args[]){
B b = new B();
b.print(); //B类中的方法
b.fun(); //B类没有覆写该方法，默认调用父类
}
}
this.方法():首先会查找子类是否存在该方法，如果存在则直接调用，如果不存在则查找父类中是否有该方法，如果有则直接调用，如果没有则出现编译错误；
super.方法():直接调用父类中的该方法，如果不存在则出现编译时的错误；
重载和覆写之间的区别：
重载（Overloading）:在一个类中进行；方法名相同，参数个数以及类型不同；方法定义的没有权限限制；
覆写（overrid）:发生在继承关系中；方法名称相同，参数个数以及类型相同，返回值相同；子类不能比父类更加严格；
一个不需要注意的继承案例
class Array{
private int data[];
private int foot;
public Array(int len){
if(len != 0){
this.data = new int[len];
}else{
this.data = new int[1];
}
}
public void add(int num){
if(this.foot>=this.data.length){
return;
}else{
this.data[foot++] =num;
}
}
public int[] getData(){
return this.data;
}
}
//定义一个排序类
class SortArray extends Array{
public SortArray(int len){
super(len);//明确调用父类的有参构造，作用是为数组初始化
}
//覆写父类方法
public int[] getData(){
java.util.Arrays.sort(super.getData());//
return super.getData();
}
}
//反转数组
class ReverseArray extends Array{
public ReverseArray(int len){
super(len);
}
public int[] getData(){
int num = super.getData().length/2;//反转次数
int head = 0;
int tail = super.getData().length - 1;
for(int x = 0;x < num;x++){
int temp = super.getData()[head];
super.getData()[head] = super.getData()[tail];
super.getData()[tail] = temp;
head ++;
tail --;
}
return super.getData();
}
}
public class Test{
public static void main(String args[]){
ReverseArray arr = new ReverseArray(3);
arr.add(1);
arr.add(10);
arr.add(3);
arr.add(4);
//arr.add(5);
int data[] = arr.getData();
for(int x=0;x<data.length;x++){
System.out.print(data[x]+"\t");
}
}
}