Java基础---继承以及访问限制修饰符

1.继承

  类与类之间关系就是继承。

  继承就是通过现有的类构建出新机制

  现有的类就是父类【超类】，构建出来的新类就是子类

   类与类之间的关系时单继承的，一个java类只能有一个父类

2.如何完成一个继承关系

   通过extends关键字实现继承

   格式：public class 子类名称 extends 父类名称{}

              class 子类名称  extends 父类名称{}

    注意：前提是父类一定存在

public  class Person{
           
}



public class Student extends Person{
     
 }

3.子类对象创建过程

子类对象创建---子类的构造方法中会默认调用父类的无参数构造方法【没有父就没有子】

子类的构造方法中，如果一定要访问父类有参数的构造方法，需要在子类的构造方法中的

第一行写出"super(参数值)"，就可以调用父类的任意一个构造方法。

父类

package com.object.test3;

public class Father {
          public Father(){
        	  System.out.println("父类无参数的构造方法");
          }
          public Father(String name){
        	  System.out.println("父类参数为name的构造方法name=="+name);
          }
}

子类

package com.object.test3;

public class Son extends Father {
        public   Son(){
        		super("zhaoxixi");
        		System.out.println("子类无参数的构造方法");
        	}
       
}

测试类

package com.object.test3;

public class TestMain {

	public static void main(String[] args) {
		       //测试子类的构造方法
	           new Son();

	}

   总结：创建子类对象需要子类构造方法，通过子类构造方法创建子类对象是默认会调用父

类的无参数构造方法的，当父类中是有参数的构造方法时，我们应该在子类的构造方法中的

第一行通过super(参数)，调用父类有参数的构造方法来完成子类对象的创建

4. 关于Java包

java包--java程序包

1.java中如何创建一个包？

   通过package关键字创建包

   格式：package 包名称;  [在类的第一行]

2.java中包的作用是什么？

   区分名称相同的Java类

   我们在使用java类的时候需要先导入这个java类所在的包。

3.怎们导包？

   通过import关键字导入需要使用的java包

   例如:import 包名+类名;   //只导入当前包中的当前类

   例如:import 包名+*;      //导入当前包中的所有类

   包名可以是一个合法的标识符，也可以 是多个合法标识符之间用"."分割

   规则：公司域名倒置.项目.功能

   注意:1.java.lang包不需要导入[java.lang包中包含的java的核心开发类，系统默认自动导入]

5.Java中的访问限制修饰符的区别和用法

访问限制修饰符----public[公共的]   缺省的[友好的]    protected[受保护的]   private[私有的]

类中----public【公共的】  缺省的【友好的】

1.public修饰的类任何地方都可以访问

2.缺省的【友好的】修饰的类不能跨包访问

类中的变量---public[公共的]   缺省的[友好的]    protected[受保护的]   private[私有的]

类中的方法---public[公共的]   缺省的[友好的]    protected[受保护的]   private[私有的]

   5.1访问限制修饰符的区别

例如：

同一个类中

package com.object.test4;

public class FatherClass {
	      //创建类中的变量
          public String publicBL="公共的";
          String queShengBL="缺省的";
          protected String protectedBL="受保护的";
          private String privateBL="私有的";
          public void testMethod1(){
        	  System.out.println("publicBL"+publicBL);
        	  System.out.println("queShengBL"+queShengBL);
        	  System.out.println("protectedBL"+ protectedBL);
        	  System.out.println("privateBL"+ privateBL);
          }
}

同一个包中的子类

package com.object.test4;

public class SonClass extends FatherClass {
	 public void testMethod2(){
   	  System.out.println("publicBL"+publicBL);
   	  System.out.println("queShengBL"+queShengBL);
   	  System.out.println("protectedBL"+ protectedBL);
   	  //System.out.println("privateBL"+ privateBL);
     }
}

同一个包中的非子类

package com.object.test4;

public class OtherClass {
	 public void testMethod3(){
		 FatherClass facl=new FatherClass();
   	  System.out.println("publicBL"+facl.publicBL);
   	  System.out.println("queShengBL"+facl.queShengBL);
   	  System.out.println("protectedBL)"+facl.protectedBL);
   	  //System.out.println("privateBL"+facl. privateBL);
     }
}

测试类

package com.object.test4;

public class TestMain {

	public static void main(String[] args) {
		/*
		 //测试FatherClass类
		FatherClass facl=new FatherClass();
		facl.testMethod1();
		*/
		/*
		 //测试SonClass类
		SonClass sca=new SonClass();
		sca.testMethod2();
		*/
		//测试OtherClass类
		OtherClass otc=new OtherClass();
		otc.testMethod3();

	}

}

不同包中子类

package com.object.test5;
import com.object.test4.FatherClass;
public class TestSunClass extends FatherClass{
	public void testMethod1(){
  	  System.out.println("publicBL"+publicBL);
  	  //System.out.println("queShengBL"+queShengBL);
  	  System.out.println("protectedBL"+ protectedBL);
  	  //System.out.println("privateBL"+ privateBL);
    }
}

不同包中非子类 

package com.object.test5;
import com.object.test4.FatherClass;
public class OtherClass {
	FatherClass faca=new FatherClass();
	public void testMethod1(){
		FatherClass faca=new FatherClass();
	  	  System.out.println("publicBL"+faca.publicBL);
	  	  //System.out.println("queShengBL"+faca.queShengBL);
	  	  //System.out.println("protectedBL"+ faca.protectedBL);
	  	 // System.out.println("privateBL"+ faca.privateBL);
	    }

}

6.Java中子类的继承性

1.java中的类是单继承。[一个java类只能继承一个父类]

2.同一个包中的子类可以继承父类中public、缺省的、protected。

3.不同包中的子类可以继承父类中public/protected修饰的变量/方法。

4.子类中的变量和方法，有一部分是子类从父类继承的，还有一部分是子类自己创建。

5.定义的java类如果没有明确的继承某个类，那么这个类默认继承了java.lang.Object类。

【一切皆对象】

 7.成员变量的隐藏

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

   7.2.如果需要强制使用被隐藏的成员变量，则使用super访问

例如：

package com.object.test6;

public class Father {
	//创建成员变量
	public String name="zhangsan";

}

package com.object.test6;

public class SonClass extends Father {
            //创建成员变量
	   public String name="lisi";
	   public void testMethod2(){
		   System.out.println("子类name=="+name);   //lisi
		   System.out.println("父类name=="+super.name);
	   }
}

package com.object.test6;

public class TestMain {

	public static void main(String[] args) {
		SonClass sca=new SonClass();
		sca.testMethod2();
		

	}

}

8.方法重写

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

例如：

package com.object.test6;

public class Father {
	
	public void testMethod(){
		System.out.println("父类的实例方法");
	}

}

package com.object.test6;

public class SonClass extends Father {
	   public void testMethod(){
		   System.out.println("子类的实例方法");
	   }
}

package com.object.test6;

public class TestMain {

	public static void main(String[] args) {
		SonClass sca=new SonClass();
		sca.testMethod();

	}

}

最后

以上就是喜悦樱桃为你收集整理的Java基础---继承以及访问限制修饰符的全部内容，希望文章能够帮你解决Java基础---继承以及访问限制修饰符所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。