继承 （extends）

【修饰符】class 子类名称 【extends 父类名称】
private 修饰的字段可以继承，只是不能访问
继承可继承一切实例，但是能不能访问看修饰符。
子类可以在原有的基础上对父类进行扩展
Java语言中，一个类只能继承一个父类

package cn.edu.ecut ; // 一个源文件中至多出现一个 package 语句
// 一个源代码文件中至多出现一个 public 修饰的 class
// 如果源代码文件存在 public 修饰的 class 则该文件名称必须与 public 修饰的 class 名称相同
public class Person {
public void eat( String foodName ) {
System.out.println( “人可以吃” + foodName );
}
}
// 没有 public 修饰的 class 只能在本包内部使用
class Human {
public void sleep() {
System.out.println( “人可以睡觉” );
}
}

package cn.edu.ecut ;
public class HumanTest1 {
public static void main(String[] args) {
Human h = new Human();
h.sleep();
}
}

package ecut ;
//【编译失败】错误: Human 在 cn.edu.ecut 中不是公共的; 无法从外部程序包中对其进行访问
import cn.edu.ecut.Human ; // 对于 非同包 中的 非 public 修饰的类，即使 import 了也仍然不可用
public class HumanTest2 {
public static void main(String[] args) {
Human h = new Human();
h.sleep();
}
}

package cn.edu.ecut ;
public class PersonTest1 {
public static void main(String[] args) {
Person p = new Person();
p.eat( “藜蒿炒腊肉” );
}
}

package ecut ;
// 引用 非同包 的 public 修饰的 class 时，可以使用 import 语句实现
import cn.edu.ecut.Person ; // import 语句在一个类中可以出现N次 ( N >= 0 )
public class PersonTest2 {
public static void main(String[] args) {
Person p = new Person();
p.eat( “藜蒿炒腊肉” );
}
}

静态方法和字段

不可以被继承
class Animal {
// 被 static 修饰的 字段 或 方法 是属于当前类的 ( 如果子类能继承不就矛盾了吗 )
public static String type ;
public String name ;
static {
System.out.println( “Animal Initialization” );
type = “动物” ;
}
}
class Monkey extends Animal {
static {
System.out.println( “Monkey Initialization” );
}
}
public class AnimalTest {
public static void main(String[] args) {
System.out.println( Monkey.type ); // 仅仅完成了对 Animal 的初始化，并没有初始化 Monkey
System.out.println( “~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~” );
Monkey m = new Monkey(); // 创建 Monkey 类的对象时导致 Monkey 被初始化
m.name = “孙悟空” ;
System.out.println( m.name ) ;
}
}

方法重载

同一个类中存在多个同名方法时，这些方法之间构成重载

同参不同名（1.名称相同
2.不同参，参数类型，个数，类型顺序不同
3.访问修饰符可以相同可以不同
4.返回类型可同可不同
5.抛出异常可以相同可以不同）
eg:
**

• 1、方法的重载

  同一个类中存在多个同名不同参的方法时，它们之间构成重载 ( 重载是相互的 )

  所谓同名是指 方法名称完全相同

  所谓不同参是指 构成重载的多个方法的 参数类型 、参数个数 、参数类型顺序 不相同 ( 只要有其中一项不相同即可 )

  重载 对 方法的 修饰符、返回类型、异常列表 等没有要求

• 
  

*/
public class SikaDeer {

public int add( int a , int b ) {
    System.out.println( "add( int , int )" );
    return a + b ;
}
protected double add( int a , double b ) {
    System.out.println( "add( int , double )" );
    return a + b ;
}
// 没有 显式 指定 访问修饰符 时即为 默认 ( 默认是 package-private )
double add( double a , int b ) {
    System.out.println( "add( double , int )" );
    return a + b ;
}
private double add( double a , double b ) {
    System.out.println( "add( double , double )" );
    return a + b ;
}
public double add( double a , double b , double c ) {
    System.out.println( "add( double , double , double )" );
    return a + b + c ;
}
public static void main( String[] args ) {
    SikaDeer s = new SikaDeer();
    int x = s.add( 100 , 200 ); // add( int , int )
    System.out.println( x );
    System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
    double y = s.add( 100D , 200.0 );  // add( double , double )
    System.out.println( y );
    System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
    double z = s.add( 100 , 200.0 );  // add( int , double )
    System.out.println( z );
    System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
    double u = s.add( 100.0 , 200 );  // add( double , int )
    System.out.println( u );
    System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
    double v = s.add( 100 , 200 , 300 );  // add( double , double , double )
    System.out.println( v );
}

}

Super关键字调用父类构造方法

1、在任意类的构造方法中，都可以通过 super( [实参列表] ) 形式来调用父类中的指定构造方法，即使参数不同比如Chinese(int age,String name)
{
super(“黄种人”)；
}

2、如果某个构造方法中没有显示书写 super( [实参列表] ) 则 【编译器】 会为构造方法添加 super() 从而调用父类中的无参构造

3、通过指定不同的参数可以调用父类中不同的构造方法

4.如果没有指定任何构造方法，则编译会为当前类添加一个默认构造方法( 公开的、无参的 、空的 )

5.如果显式指定了带参数的构造方法，则编译器不再为当前类添加默认构造方法

 为了将来能够使用无参数的构造方法，就需要显式书写无参数构造方法

6.对于构造方法来说，多个构造方法之间可以构成重载

  一个类中所有的构造方法都是与类名同名的，因此它们的名称一定是相同的。

  当多个构造方法的参数不相同( 类型、个数、顺序 ) 时，它们之间就构成重载

7.当一个类中存在多个重载的构造方法时，创建该类的对象时会根据参数来确定到底调用哪一个构造方法。

子类可以重新声明父类中的成员

子类声明了父类中同名的字段（父类子类可见）
此时子类中使用的，该对应的字段是，会使用子类的字段，而不是父类继承的，可见的字段。

构造方法的调用的执行

子类构造方法可以使用super关键字（【实参】）形式来调用父类的构造方法。
除了Object类之外，所有类的构造内部都会首先调用父类构造。
创建某个实例时，调用顺序是子类调用父类，知道Object为止。而执行顺序刚好相反。

方法重写

当子类中声明了与从父类中继承的(可见的)方法 同名、同参、同返回 的方法时，
就说 子类中的 同名方法 重写了 ( 覆盖了 ) 父类中的同名方法，
当通过子类类型的对象 调用 该名称的方法时，会执行子类中声明的方法

2、不要制造新名词，可以使用 重写 或 覆盖 都对应 override
3、同名、同参、同返回
同名: 子类中重新声明的方法的名称与从父类中继承的、可见的方法名称完全相同
同参: 子类中重新声明的方法的名称与从父类中继承的、可见的同名方法参数相同
同返回:
父类方法如果返回 基本类型 或 void ，则子类中重写后的方法返回类型必须与父类方法的返回类型相同
如雷方法中如果返回引用类型，则子类重写后的方法返回类型需要与父类方法的返回

this和super

1、如果一个类中存在多个相互重载的构造方法，则通过 this( [ 实参列表 ] ) 可以调用其它构造方法
2、如果父类中存在多个相互重载的构造方法，则通过 super( [ 实参列表 ] ) 可以调用父类中指定的构造方法

public class MashiMaro extends Object { // 兔 : 流氓兔
private String name ;
private int age ;
public MashiMaro(){
super(); // 通过参数确定调用的是父类中的无参数构造
System.out.println( “MashiMaro()” );
}
public MashiMaro( String name ) {
// super(); // 通过参数确定调用的是父类中的无参数构造
this(); // 通过参数确定调用本类构造中的无参数构造
this.name = name ;
System.out.println( “MashiMaro( String )” );
}
public MashiMaro( String name , int age ) {
this( name ); // 通过参数确定调用本类构造中的有参数构造( MashiMaro(String) )
this.age = age ;
System.out.println( “MashiMaro( String , int )” );
}
public void show(){
// System.out.println( super ); //【编译失败】super 不能单独使用
System.out.println( this ); // this 关键字可以单独使用，表示当前对象本身
}
public static void main(String[] args) {
MashiMaro m = new MashiMaro( “流氓” , 4 );
System.out.println( m ); // m.toString()
}
}

相同点：
1.都可以用来调用构造方法。
2.都可以访问字段。
3.都可以用来调用方法。
4.都可以用来访问类变量和类方法。
5.不能出现在static中。
区别：
1.通过this可以调用本类中其他构造方法。而super([参])可以调用父类指定的构造方法。
2.使用this.字段名称可以访问本类中直接声明的字段，也可以访问从父类继承的（可见的）字段。
而supe只能完成访问父类继承的字段（可见的）可以是直接继承也可以是间接继承。
3.使用this.方法名（）可以访问本类中直接声明的字段，也可以访问从父类继承的（可见的）方法。
而supe只能完成访问父类继承的方法（可见的）可以是直接继承也可以是间接继承。
3.this可以单独使用表示对象本身，System.out.println(this());
而super不可以，super只能通过super([实参列表])或super.来使用，super不能表示父类实例。