Java中的继承

一、继承的概念

类与类之间有关系，这种关系就是继承
继承就是通过现有的类构建出新类的机制
现有的类叫父类【超类】，构建出来的心类叫子类
类与类之间的继承关系是单继承，一个是Java类只能有一个类。

二、如何完成一个继承类关系？

  通过extends关键字实现继承关系
格式：public class 子类名称  extends  父类名称{ }  (公共的)
          class  子类名称  extends  extends 父类名称{}  （有好的/缺省的）
public  class  Person{      }  //父类
public class  Student  extends  Person{ } //子类Student继承父类Person

三、子类对象创建过程

      子类对象创建–子类的构造方法中会默认调用父类的无参数构造方法【没有付就没有字】
      子类的构造方法中，如果一定要访问父类有参数的构造方法，就需要在子类的构造方法中的第一行通过“super(参数值)”，就可以指定调用父类的任意一个构造方法。
        public class Person{
                public Person(){
                        System.out.println(“父类无参数构造方法”);
                } }
        public  class  Student  extends  Person{
                public  Student(){
                        //隐藏了super();
                        System.out.println(“子类无参数的构造方法”);
                }}

        等价于
        public class Person{
                public Person(){
                        System.out.println(“父类无参数构造方法”);
                } }
        public  class  Student  extends  Person{
                public  Student(){
                        super();  //父类无参数构造方法
                        System.out.println(“子类无参数的构造方法”);
                }}
例如：创建父类

package com.wangxing.test2;

/**
 * 创建父类
 * @author 联想
 *
 */
public class fuClass {
	public fuClass(){
		System.out.println("父类的无参数构造方法");
	}
}

创建子类

package com.wangxing.test2;

/**
 *创建子类
 * @author 联想
 *
 */
public class sunClass extends fuClass{
	public sunClass(){
		System.out.println("子类的无参数构造方法");
	}
}

  总结:创建子类对象需要子类的构造方法，通过子类构造方法创建子类对象是默认会调用父类的无参数构造方法，当父类没有无参数构造方法时，我们应该在子类的构造方法中的第一行通过super(参数)，调用父类有参数得构造方法来完成子类对象的创建。

四、关于java包

java包–java程序包
java中如何创建一个包？
   通过package关键字创建包
   格式:     package 包名称;  [类的第一行]
java中包的作用是什么？
    区分名称相同的Java类
    我们在使用java类的时候需要先导入这个java类所在的包。
怎么导包？
    通过import关键字导入需要使用的java包
    例如:import 包名+类名;   //只导入当前包中的当前类
    例如:import 包名+*;      //导入当前包中的所有类
    包名可以是一个合法的标识符，也可以是多个合法标识符之间用”.”分割
    规则：公司域名倒置.项目.功能
注意:1.java.lang包不需要导入。[java.lang包包含的java的核心开发类，系统默认自动导入]

五、Java中的访问修饰符的区别和用法 

访问限制修饰符—-public【公共的】  缺省的【友好的】  protected【受保护的】 private【私有的】
类中—public【公共的】  缺省的【友好的】
1.public修饰的类任何地方都可以访问。
2.缺省的【友好的】修饰的类跨包不能访问。
类中变量–public【公共的】  缺省的【友好的】  protected【受保护的】 private【私有的】
类中方法–public【公共的】  缺省的【友好的】  protected【受保护的】 private【私有的】

修饰符	同一个类中	同一个包的非子类	同一个包中的子类	不同包子类	不同包非子类
public	可以	可以	可以【继承】	可以【继承】	可以【继承】
protected	可以	可以	可以【继承】	可以【继承】	不可以
缺省的	可以	可以	可以【继承】	不可以	不可以
private	可以	不可以	不可以	不可以	不可以

例如：同一类中

package com.wangxing.test3;

/**
 * 父类
 * @author 联想
 *
 */
public class fuClass {
	public String str1="public修饰符";
	protected String str2="protected受保护的修饰符";
	String str3="缺省的修饰符";
	private String str4="private私有的修饰符";
	public fuClass(){}
	public void method1(){
		System.out.println("父类的"+str1);
		System.out.println("父类的"+str2);
		System.out.println("父类的"+str3); 
		System.out.println("父类的"+str4);
	}
}

例如：在同一个包中不同类

package com.wangxing.test3;
/**
 *非子类
 * @author 联想
 *
 */
public class feiSunClass {
	public void method(){
		//利用对象调用fuClass类的不同修饰符修饰的变量
		System.out.println("fuClass类的变量"+new fuClass().str1);
		System.out.println("fuClass类的变量"+new fuClass().str2);
		System.out.println("fuClass类的变量"+new fuClass().str3);
		//一个包的不同类中不能使用私有修饰符
		//System.out.println("fuClass类的变量"+new fuClass().str4);
	}
}

例如：
同一个包中的子类

package com.wangxing.test3;
/**
 * 创建fuClass类的同包子类
 * @author 联想
 *
 */
public class sunClass extends fuClass{
	public sunClass(){
		//隐藏了super();
		System.out.println("子类继承父类的变量"+str1);
		System.out.println("子类继承父类的变量"+str2);
		System.out.println("子类继承父类的变量"+str3);
		//私有的修饰符不能继承
		//System.out.println("子类继承父类的变量"+str4);
		//调用同包的子类方法
		super.method2();
		super.method3();
		super.method4();
		//不能继承父类中的私有修饰符
		//super.method5();
	}
}

package com.wangxing.test3;

public class testmain {
	public static void main(String args[]){
		/*fuClass fc=new fuClass();
		//调用fuClass中的方法
		fc.method1();
		fc.method2();
		fc.method3();
		fc.method4();
		//私有的修饰符不能在其他包使用不同类使用
		//fc.method5();
		 * *
		 */
		/*feiSunClass fsc=new feiSunClass();
		fsc.method();*/
		sunClass sc=new sunClass();
	}
}

上面这个代码是测试类
例如：不同包的子类

package com.wangxing.test4;
import com.wangxing.test3.fuClass;

/**
 * 不同包中的子类
 * @author 联想
 *
 */
public class sunClass extends fuClass {
	public sunClass() {
		// 隐藏了super();
		System.out.println("子类继承父类的变量" + str1);
		System.out.println("子类继承父类的变量" + str2);
		//不同包的子类不能继承缺省的修饰符
		//System.out.println("子类继承父类的变量" + str3);
		// 私有的修饰符不能继承
		//System.out.println("子类继承父类的变量"+str4);
		// 调用不同包的子类方法
		super.method2();
		//不能继承不同包的子类缺省修饰符
		//super.method3();
		super.method4();
		// 不能继承不同包父类中的私有修饰符
		//super.method5();
	}
}

例如：不同包的非子类

package com.wangxing.test4;
import com.wangxing.test3.fuClass;

/**
 * 不同包的非子类
 * @author 联想
 *
 */
public class feiClass {
	public feiClass() {
		// 利用对象调用不同包的fuClass类的不同修饰符修饰的变量
		System.out.println("fuClass类的变量" + new fuClass().str1);
		//不同包的非子类不能调用受保护的修饰符
		//System.out.println("fuClass类的变量" + new fuClass().str2);
		//不同包的非子类不能调用缺省修饰符
		//System.out.println("fuClass类的变量" + new fuClass().str3);
		// 不同包的非子类中不能使用私有修饰符
		// System.out.println("fuClass类的变量"+new fuClass().str4);
		// 调用不同同包的类方法
		//不包的类不能调用受保护的修饰符
		//new fuClass().method4();
		//不包的类不能调用缺省修饰符
		//new fuClass().method3();
		new fuClass().method2();
		// 私有的调用不了new fuClass().method5();
	}
}

 

package com.wangxing.test4;
public class testmain {

	public static void main(String[] args) {
		//sunClass sc=new sunClass();
		feiClass fc=new feiClass();
	}
}

上面代码是测试不同包类：

 

六.Java中子类的继承性

1.java中的类是单继承。[一个java类只能继承一个父类]
2.同一个包中子类可以继承父类中除过private修饰的变量/方法。
3.不同包中的子类可以继承父类中public/protected修饰的变量/方法。
4.子类中的变量和方法，有一部分是子类从父类继承的，还有一部分是子类自己创建。
5.定义的java类如果没有明确的继承某个类，那么这个类默认继承了java.lang.Object类。
  【一切皆对象】

 七、成员变量的隐藏

1.在同一个类中，局部变量的名称与某一个成员变量的名称相同

例如；

package com.wangxing.test5;

/**
 * 父类
 * 
 * @author 联想
 *
 */
public class Person {
	//成员变量
	public String name = "zhangsan";
	
	public void testmethod() {
		// 局部变量
		char name = 'A'; 
		System.out.println("name==" + name); //A [成员变量的隐藏]
		//需要强制使用被隐藏的成员变量，this访问
		System.out.println("name==" + this.name);
	}
}

 2.在子类中的某一个成员变量的名称与父类某一个成员变量的名称相同

例如：

package com.wangxing.test5;

/**
 * Person的子类
 * 
 * @author 联想
 *
 */
public class Student extends Person {
	// 成员变量
	public char name = '好';
	public void testMethod() {
		System.out.println("name==" + name); // 好 [成员变量的隐藏]
		// 需要强制使用被隐藏的成员变量，super访问
		System.out.println("name==" + super.name); // person
	}
}

八、方法的重写

         在子类中某一个方法与父类中的某一个方法相同，此时就是子类重写父类的方法。

package com.wangxing.test6;

public class fuClass {
	public void testinfo(){
		System.out.println("Person的实例方法");
	}
}

package com.wangxing.test6;

public class sunClass extends fuClass{
	//方法重写
	public void  testInfo(){
		System.out.println("SunClass的实例方法");
	}
}