Java继承超详细教程

class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}

class teacher{             //声明一个teacher类为父类
	String name;      	   //定义父类的成员变量name、age   
	int age;
	void show(){           //定义父类成员方法，将成员变量输出
		System.out.println(name); 	  
		System.out.println(age); 
	}
}
class Student extends teacher {     //声明一个Student类为子类并继承父类
}
public class myfirst {
	public static void main(String[] args) {
	System.out.println("学生");
	Student student=new Student();     //声明一个Student类的实例对象student
	student.name="Tom";                //子类调用父类的成员变量name并赋值
	student.age=19;                    //子类调用父类的成员变量age并赋值
	student.show();                    //子类调用父类的成员方法show
	}
}

class A{
	public void sayHello() {                      //输出英文欢迎
		System.out.println("Hello,Welcome to Java!!!");
	}
	public void sayBye() {
		System.out.println("GoodBye,everyone");
	}
}
class B extends A {           
    public void sayHello() {                      //输出中文欢迎  
    	System.out.println("大家好，欢迎学习Java！！！");
    }
}
public class myfirst {
	public static void main(String[] args) {
	B b=new B();                                //创建子类B的一个实例对象，使用默认构造方法
	b.sayHello();                               //调用子类中重写的方法
	b.sayBye();                                 //调用父类中的方法
	}
}

class A{
	public static void sayHello() {             //静态类方法
		System.out.println("大家好，这是A的静态类方法");
	}
	public void sayHello2() {                   //实例方法
		System.out.println("大家好，这是A中的实例方法");
	}
}
class B extends A {    
    public static void sayHello() {             //静态类方法
    	System.out.println("大家好，这是B的静态类方法");
    }
    public void sayHello2() {                   //实例方法
    	System.out.println("大家好，这是B的实例方法");
    }
}
public class myfirst {
	public static void main(String[] args) {
	    B b=new B();                           //创建B类的实例对象b
	    A a=b;                                 //隐式对象类型转换
	    A.sayHello();                          //调用A类的静态类方法
	    a.sayHello();                          //调用a对象的静态类方法
	    B.sayHello();                          //调用B类的静态方法
	    a.sayHello2();                         //调用a对象的实例方法
	    b.sayHello2();                         //调用b对象的的实例方法
	    A a2=new A();                          //创建A类的实例对象a2
	    a2.sayHello2();                        //调用a2对象的实现方法
	}
}

class A{                     //父类A
	private int value=10;    //声明一个私有变量value并赋值为10
	public int getvalue() {  //声明一个公有成员方法getvalue，返回value
		return value;
	}
}
class B extends A{           //A的子类B
}
public class myfirst {    
	public static void main(String[] args) {
	  B b=new B();           //创建子类B的一个实例对象
	  System.out.println("子类通过父类提供的公共接口访问A中的私有字段value:"+b.getvalue());
	}
}

package first;
class A{
    public String name="张飞";         //添加成员变量
	public void say() {                //添加成员方法say
		System.out.println("我是父类A成员方法say");
	}
}
class B extends A{
    public String name="关羽";         //与父类中同名的字段，隐藏父类
	public void say(){                 //重写方法say
		super.say();                   //使用super关键字调用父类中的方法
		System.out.println("我是子类B成员方法say");
        System.out.println("父类的name名字："+super.name); //使用super关键字访问父类中的变量
	}
}
public class myfirst {
	public static void main(String[] args) {
	  B b=new B();                     //创建子类的一个实例对象
	  b.say();                         //调用子类中重写的方法
	  System.out.println("子类的name名字："+b.name);   //调用子类中的name
	}
}

class SuperClass {              //创建父类SuperClass
	  private int n;            //声明一个私有变量n
	  SuperClass(){             //父类无参数构造方法
	    System.out.println("这是父类SuperClass无参数构造方法");
	  }
	  SuperClass(int n) {       //父类有参数构造方法
	    System.out.println("这是父类SuperClass有参数构造方法");
	    this.n = n;
	  }
	}
	class SubClass extends SuperClass{     // SubClass类继承SuperClass类
	  private int n;                       //声明一个私有变量n
	  SubClass(){                          // 自动调用父类的无参数构造器
	    System.out.println("这是子类无参数构造方法");
	  }  
	  public SubClass(int n){              //子类有参数构造方法
	    super(300);                        //调用父类中带有参数的构造器
	    System.out.println("这是子类有参数构造方法"+n);
	    this.n = n;
	  }
	}
public class myfirst {
	public static void main(String[] args) {
		    SubClass sc1 = new SubClass();      //创建子类SubClass实例对象，调用其无参数构造方法
		    SubClass sc2 = new SubClass(100);   //创建子类SubClass实例对象，调用其有参数构造方法
	}
}