this和super不能出现在static的方法中
重写：方法名和参数都相同，子类覆盖父类
重载：方法名相同，参数列表个数和类型不同
重写模块
class Bird {
public void fly() {
System.out.println("fly in the sky");
}
}
public class TestOverride extends Bird {
public void fyl(){
System.out.println("fly on the ground");
}
public static void main(String[] args) {
TestOverride p = new TestOverride();
p.fyl();
}
}
- 重载模块
public class TestOverload {
public String name;
public String color;
public int age;
public TestOverload(){
System.out.println("无参的构造方法");
}
public TestOverload(String name,String color) {
this.name = name;
this.color = color;
System.out.println("有2个参数的构造方法");
}
public TestOverload(String name,String color,int age) {
this(name,color); //这里的this 引用了上一个构造器里的内容，必须放在第一行
this.age = age;
System.out.println("有3个参数的构造方法");
}
public static void main(String[] agrs) {
TestOverload p = new TestOverload();
TestOverload p1 = new TestOverload("chenanle","blue",24);
}
}
在一个构造器中调用另一个重载的构造器使用this来实现，在子类构造器中调用父类的构造器使用super来实现
以下代码先打印父类中的语句，再打印出后面一条语句
class sub {
public double size;
public String name;
public sub(){}
public sub(double size,String name) {
this.size = size;
this.name = name;
System.out.println("先打印父类中的语句");
}
}
public class TestSub extends sub {
public String color;
public TestSub(String color,double size,String name) {
super(size,name);
this.color = color;
System.out.println("再打印子类中的语句");
}
public static void main(String[] args) {
TestSub ts = new TestSub("blue",5.6,"chenanle");
System.out.println("最后打印如下语句");
System.out.println(ts.size +"--"+ts.color+"--"+ts.name);
}
}
结果为：
先打印父类中的语句
再打印子类中的语句
最后打印如下语句
5.6--blue--chenanle
多态
class BaseClass{
public int book = 6;
public void base() {
System.out.println("父类普通的方法");
}
public void test() {
System.out.println("父类被重写的方法");
}
}
class SubClass extends BaseClass {
public String book = "books";
public void sub() {
System.out.println("子类普通的方法");
}
public void test() {
System.out.println("子类重写父类的方法");
}
}
public class TestDuoTai {
public static void main(String[] args){
BaseClass bc = new BaseClass();
System.out.println(bc.book);
bc.test();
bc.base();
SubClass sc = new SubClass();
System.out.println(sc.book);
sc.test();
sc.base();
BaseClass polymorphism = new SubClass(); //多态 ，向上转型
System.out.println(polymorphism.book);
polymorphism.base();
polymorphism.test();
}
}
- 打印结果为：
6
父类被重写的方法
父类普通的方法
books
子类重写父类的方法
父类普通的方法
6
父类普通的方法
子类重写父类的方法
- BaseClass polymorphism = new SubClass();它编译时类型是BaseClass，运行时是SubClass，当调用引用变量的test()方法是，实际上是调用了子类里的test()方法，因为父类里的test()方法被子类重写了（覆盖了），这就是多态。
