12.Java中的继承

1.什么是继承
    1.继承表示的是一种类与类之间的关系
    2.继承---是由现有的类创建出新类的一种机制
      现有的类---父类【超类】
      新类---------子类

2.如何完成一个继承关系
    通过extends关键创建继承关系
    格式 : public  class  NewClass  extends  OldClass{}
    NewClass---子类
    OldClass----父类【超类】

注意：1.一个类只能继承一个父类
           2.如果一个类没有使用extends，那么这个类默认继承了java.long.Object类
           public  class  Hello{}      
           public  class  Hello  extends  Object{}
           public  class  MyClass  extends Hello{}
           因为Object是对象的意思，所以所有的java类都是java.long.Object类的子类。
           [一切皆对象]

3.子类对象创建过程
    1.子类在创建对象的时候，默认先调用父类无参数的构造方法。
    2.当父类中没有了无参数的构造方法时，在子类的构造方法中的第一句使用super(参数)

    super(参数)在子类的构造方法中表示调用父类有参数的构造方法。
    super()在子类的构造方法中表示调用父类无参数的构造方法。
    总结:子类在创建对象的时候,总是先调用父类构造方法。

创建父类:

package zx.javatest.a;
//创建一个父类
public class Test1 {
	public Test1(){
		System.out.println("父类的无参数构造方法");
	}
	public Test1(String name){
		System.out.println("父类的有参数构造方法");
	}
}

创建子类：

package zx.javatest.a;
//创建一个子类
public class Test2 extends Test1{

		public Test2(){
			super("小白");
			System.out.println("子类的无参数构造方法");
		}
		
}

4.Java中的包是什么
    包指的是java的程序包

5.Java中包的作用是什么
    1.整理java类/java接口...方便管理和维护
    2.可以区分名称相同的java类

6.Java包的具体用法？
    创建包：package  包名称;
    包名称：可以用一个合法的标识符
                  也可以使用多个合法的标识符中间"."分割。
    包名称的基本格式: 公司域名倒置.项目.功能
                         例如: com.baidu.map.location
                                  com.wangxing.extendstest.test1
    导入程序包：import 包名称.*;   //导入所有
                         import 包名称.类名称;  //导入指定包中的指定类
    位置：创建包的语句与创建类的语句之间 

7.java 中的访问限制修饰符的区别和用法
    访问限制修饰符：public  缺省的  protected private
    java类--public  缺省的
    public修饰的java类可以在任何地方使用。

创建public、String、protected、 private修饰符、修饰方法

package zx.javatest.d;
//同一个包中
public class Test1 {
	public String test1 = "public修饰符";
	String test2 = "缺省修饰符";
	protected String test3 = "protected修饰符";
	private String test4 = "private修饰符";
	
	public void fangfa1(){
		System.out.println("public修饰符的方法");
	}
	
	void fangfa2(){
		System.out.println("缺省修饰符的方法");
	}
	
	protected void fangfa3(){
		System.out.println("protected修饰符的方法");
	}
	
	private void fangfa4(){
		System.out.println("private修饰符的方法");
	}
	
	public void testa(){
		System.out.println("test1---"+test1);
		System.out.println("test2---"+test2);
		System.out.println("test3---"+test3);
		System.out.println("test4---"+test4);
		
		fangfa1();
		fangfa2();
		fangfa3();
		fangfa4();
	}
}

缺省的修饰的java类只能在本包中的类中使用。

package zx.javatest.d;
//同一个包中非子类
//非子类需要创建对象
public class Test2 {
	
	public void testa(){
		Test1 t1 = new Test1();
		System.out.println("test1---"+t1.test1);
		System.out.println("test2---"+t1.test2);
		System.out.println("test3---"+t1.test3);
//错误	System.out.println("test4---"+t1.test4);
		
		t1.fangfa1();
		t1.fangfa2();
		t1.fangfa3();
//错误	t1.fangfa4();
	}
}

结论：

 

8.Java中子类的继承性
子类的继承性指得是:子类可以从父类继承到哪些元素，不能继承到哪些元素与java元素的访问限制修饰符有关
1.同一个包中的子类可以继承public，缺省的，protecte修饰的变量和方法
2.不同包中的子类可以继承public，protecte修饰的变量和方法
3.子类中的元素有些是从父类继承，有些是原本就属于子类自己的。

9.什么是方法重写？
 方法重写--子类中某个方法与继承自父类的方法一样，这种现象就是子类重写了父类的重写。
 

package zx.javatest.f;
//方法重写
//父类
public class Testa {
	
	public  String  chengyuan = "zhangsan";
	
	public void test1(){
		System.out.println("test1的public方法");
	}
	
	private void test2(){
		System.out.println("test1的private方法");
	}
}



package zx.javatest.f;
//子类
public class Testb extends Testa{
	//成员变量的隐藏
	public  int  chengyuan = 123;
	//强制使用被隐藏的成员变量值：super.成员变量名称
	public void test1(){
		//子类与父类的成员变量相同
		System.out.println("Testb的public方法");
		System.out.println("成员变量--"+chengyuan);
		System.out.println("成员变量--"+super.chengyuan);
	}
	//私有
	private void test2(){
		System.out.println("Testb的private方法");
	}
}



package zx.javatest.f;
//执行
public class Testm{

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Testb tb = new Testb();
		tb.test1();
//		tb.test2();
	}

}

 

10.方法重载与方法重写的区别

方法重载--同一个类中方法名称相同，参数不同
方法重写--子类中的方法与父类中继承来的方法相同

11.成员变量的隐藏

含义1---同一个类中局部变量与成员变量的名称相同
含义2---子类中某个成员变量的名称与父类中继承来的成员变量的名称相同

12.什么是上转型对象及其基本特征？
上转型对象---子类对象赋值给他的父类变量
子类对象赋值给他的父类变量，此时父类变量认为自己保存的是父类的对象
上转型对象只能访问父类的变量和方法，不能访问子类自己的变量和方法
如果一定要使用上转型对象访问子类自己的变量和方法要将上转型对象强制类型转换成子类对象
格式：低类型    低变量=(低类型)上转型对象
 

package zx.javatest.g;
//上转型对象
//父类
public class Test1 {
	public void test1(){
		System.out.println("父类的实例方法");
	}

}





package zx.javatest.g;
//子类
public class Test2 extends Test1{
	
	public void test2(){
		System.out.println("子类的实例方法");
	}

}





package zx.javatest.g;
//执行类
public class Testm {

	public static void main(String[] args) {
		//子类对象转换成
		Test1 t1 = new Test2();
		t1.test1();//访问父类的方法
//		上转型对象只能访问父类的变量和方法
//		不能访问自己的的变量和方法
//		如果一定要使用子类自己的变量和方法
//		将上转型对象强制类型转换成子类对象
//		低类型    低变量=(低类型)上转型对象
		Test2 t2 = (Test2)t1;
		t2.test2();
	}

}