继承
继承的本质是对某一批类的抽象。
关键字extends
:扩展。子类继承父类,即子类是父类的扩展。Java只有单继承,没有多继承。
(1)继承是类与类之间的一种关系。除此之外,类与类之间还有依赖、组合、聚合等。
(2)继承关系的两个类:一个为子类(派生类),一个为父类(基类)。子类继承父类通常使用extends
。
(3)子类与父类之间从意义上讲应该是“is a”的关系。
修饰符:public
公共的,protected
保护的,default
默认的,private
私有的。
例:父类:Person,子类:Student、Teacher
快捷键ctrl+H
, 可以得到该类的继承关系,例如:Object->Person->Student
//Person 父类
public class Person {
//修饰符
private int money = 10_0000_0000;
public void say(){
System.out.println("说!");
}
//封装 get, set
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
//Student is Person : 子类,派生类
//子类继承了父类,就会拥有父类的全部方法
public class Student extends Person{
//ctrl+H 得到该类的继承关系Object->Person->Student
}
//Teacher is Person : 子类,派生类
public class Teacher extends Person{
}
子类继承了父类,就会拥有父类的全部方法。所以Student类实例化的对象,可以拥有属性money
,方法say
:
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.getMoney());
}
运行结果:
说!
1000000000
Object类
在Java中所有的类都默认直接或间接继承object类。
//JAVA中,所有的类,都默认直接或间接地继承Object类
public class Person extends Object{
}
super
super的作用是调用父类。
注意点:
(1)super调用父类的构造方法的语句:super();
,必须放在构造方法的第一行;
(2)super必须只能出现在子类的方法或者构造方法中;
(3)super和this不能同时调用构造方法。
与this相比较:this的作用是调用自身。
(1)代表的对象不同:
- super:代表父类对象的引用;
- this:本身调用者的对象;
(2)前提:
- super:只能在继承条件下才可以使用;
- this:没有继承关系也可以用;
(3)构造方法:
- super(); //调用父类的构造方法
- this(); //调用自身的构造方法
父类:Person
public class Person /*extends Object*/{
public Person() {
System.out.println("Person无参构造器");
}
protected String name = "大乔";
public void print(){
System.out.println("Person");
}
}
子类:Student
//Student is Person : 子类,派生类
//子类继承了父类,就会拥有父类的全部方法
public class Student extends Person {
//ctrl+H 得到该类的继承关系Object->Person->Student
//构造器
public Student() {
//隐藏代码:调用了父类的无参构造器
super();//必须放在子类构造器的第一行
//this();//调用自己的构造器,也必须放在自己的构造器的第一行
System.out.println("Student无参构造器");
}
//有参构造器
public Student(String name) {
this.name = name;
}
public String name = "小乔";
public void print(){
System.out.println("Student");
}
public void test(String name){
System.out.println(name);//传递的形参name
System.out.println(this.name);//Student的实例化对象的属性name
System.out.println(super.name);//继承的Person父类的属性name
}
public void test1(){
print();//当前类的print方法
this.print();//当前类的print方法
super.print();//继承的父类的print方法
}
}
main
方法
public static void main(String[] args) {
Student student = new Student();
student.test("孙权");
student.test1();
}
运行结果:
Person无参构造器
Student无参构造器
孙权
小乔
大乔
Student
Student
Person
方法重写Override
重写都是方法的重写,与属性无关!
重写:需要有继承关系,然后子类重写父类的方法,必须是非静态方法。其中,子类的方法必须与父类一致,方法体不同。
注意点:
(1)方法名必须相同;
(2)参数列表(参数类型,参数名)必须相同;
(3)修饰符:范围可以扩大,public<protected<default<public;
(4)抛出异常:范围可以缩小,但不能扩大。
为什么需要重写?
因为父类的功能,子类不一定需要或者不一定满足。
快捷键:Alt+Insert-->Overried
重要例子!!!
父类:B
public class B {
//方法
public void test(){
System.out.println("B/test");
}
}
子类:A
public class A extends B{
//Override 重写只能是非静态方法,修饰符为public
//子类重写了父类的(非静态)方法
@Override//注解:有功能的注释
public void test() {
//默认调用父类的test()
//super.test();
System.out.println("A/test");
}
}
main
方法
//A,B中test()方法是静态方法或非静态方法的结果不同
//1. A,B中test()方法是静态方法
//方法的调用只与左边定义的数据类型有关
//c.test();//B
//2.A,B中test()方法是非静态方法
A a = new A();
a.test();//静态A,非静态A
B b = new B();
b.test();//静态B,非静态B
//父类的引用指向子类
//B类的引用c指向了A类
B c = new A();
c.test();//静态B,非静态A