1 继承

继承的实现：public class 子类 extends 父类 {… }

注释：子类可直接使用，父类（保护，公开）的属性和方法

优点：减少重复代码，缺点：只能单继承

// 父类
public class Test {private String str1; //私有String str2;         //默认protected String str3;// 保护public String str4;    //公开private void fn1() {} //私有void fn2() {}         //默认protected void fn3() {}// 保护public void fn4() {}   //公开
}

// 子类
public class SubTest extends Test {public void subFn1() {String t3 = str3;String t4 = str4;fn3();fn4();}
}

2 子类实例化

子类构造器默认先调用父类无参构造器（可省略），父类没有无参构造器（必须先显示调用有参构造器）

public class 子类 extends 父类 {public 子类() {[super();] // 可省略子类处理…}
}

3 方法重写

注释：子类定义了与父类相同的方法（方法重写）

// 父类
public class Test {public String name = "张三";public void doTest() {System.out.println(name);}
}

测试类1：子类未重写方法，调父类方法使用的是父类属性（不会输出子类同名属性）

// 子类
public class SubTest1 extends Test {public String name = "李四";
}

public class Main {public static void main(String[] args) {SubTest1 s = new SubTest1(); System.out.println(s.name); //输出 李四s.doTest();  //输出 张三（子类没有该方法，父类该方法输出父类名字）}
}

测试类2：子类重写属性方法后，使用的是子类的属性

//子类
public class SubTest2 extends Test {public String name = "李四";public void doTest() {System.out.println("son:"+name);} 
}

public class Main {public static void main(String[] args) {SubTest2 s = new SubTest2();System.out.println(s.name); // 输出 李四s.doTest();// 输出 son:李四}
}

测试类3：子类对象定义为父类类型，输出父类属性，调用的是子类方法

//子类
public class SubTest2 extends Test {public String name = "李四";public void doTest() {System.out.println("son:"+name);} 
}

public class Main {public static void main(String[] args) {Test s = new SubTest2();System.out.println(s.name);  // 输出 张三s.doTest();   // 输出 son:李四}
}

测试类4：子类对象强转父类类型，输出父类属性，调用的是子类方法

//子类
public class SubTest2 extends Test {public String name = "李四";public void doTest() {System.out.println("son:"+name);} 
}

public class Main {public static void main(String[] args) {SubTest2 s = new SubTest2();Test ss = (Test)s;System.out.println(ss.name);  // 输出 张三ss.doTest();  // 输出 son:李四}
}

4 方法重载

方法名(相同)，参数(个数或类型)(不同），与返回值无关

public class Test {public String fn(String str){ }// 重载1，参数类型不同public String fn(int num) {}// 重载2，参数个数不同public String fn(int age, int num) {}}

5 super关键字

注释：只可在子类内部使用，使子类可以使用父类原生方法与属性

(1) 调用父类构造器：super([参数…]);

(2) 调用父类属性：super.属性; // 获取与更改父类的属性，不影响子类同名属性

(3) 调用父类方法：super.方法(); // 调用父类的方法，与子类是否重写无关

// 父类
public class Test {private String str1 = "私有";String str2 = "默认";protected String str3 = "保护";public String str4 = "公开";private String fn1() { return str1; }String fn2() { return str2; }protected String fn3() { return str3; }public String fn4() { return str4; }
}

// 子类
public class SubTest extends Test {protected String str3 = "保护(son)";public String str4 = "公开(son)";protected String fn3() { return str3; }public String fn4() { return str4; }// 调用父类构造器（默认不写也调用）public SubTest() {super();}// 调用父类方法public void test() {System.out.println(super.str3);  // 输出 父类 保护System.out.println(super.str4);  // 输出 父类 公开System.out.println(super.fn3());  // 输出 父类 保护System.out.println(super.fn4());  // 输出 父类 公开}public void testSub() {System.out.println(str3);  // 输出 子类 保护(son)System.out.println(str4);  // 输出 子类 公开(son)System.out.println(fn3());  // 输出 子类 保护(son)System.out.println(fn4());  // 输出 子类 公开(son)}
}