继承

最新推荐文章于 2025-12-01 13:49:36 发布

原创最新推荐文章于 2025-12-01 13:49:36 发布 · 100 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

继承

5.1.什么是继承？

1.继承体现的是一种父子关系。

2.由一个已有的类创建出新类的机制。【扩展】

已有的类----父类

新类-----------子类

3.面向对象的特征

5.2.如何完成一个继承关系？

已有的类----父类

新类-----------子类

通过extends关键字实现继承关系

继承格式:

public class 新类 extends 父类{

}

例如：

public class Person{

}

public class Student extends Person{

}

Student----子类,Person----父类，Student子类是对Person父类的扩展。

5.3.子类对象创建过程

对象创建----需要依赖于构造方法

子类对象创建---需要依赖于子类的构造方法，子类的构造方法中会默认调用父类的构造方法【没有父就没有子】，如果一定要强制访问调用父类有参数的构造方法，就需要在子类的构造方法中的第一行通过“super(参数值)”，就可以指定调用父类的任意一个构造方法。

例如：

package com.wangxing.demo1;
public class Person {
	public  Person() {
		System.out.println("父类无参数的构造方法");
	}
	public  Person(String name) {
		System.out.println("父类有参数的构造方法--参数name=="+name);
	}
}

package com.wangxing.demo1;
public class Student extends Person{
//子类对象创建---需要依赖于子类的构造方法，子类的构造方法中会默认调用父类的构	//造方法【没有父就没有子】，如果一定要强制访问调用父类有参数的构造方法，就需	//要在子类的构造方法中的第一行通过“super(参数值)”，就可以指定调用父类的任意	//一个构造方法。

	public  Student() {
		super(); //父类的无参数构造方法[默认可以省略]
		//super("zhangsan"); //父类的有参数构造方法
		System.out.println("子类Student的无参数构造方法");
	}
}

package com.wangxing.demo1;
public class Test1 {
	public static void main(String[] args) {
		new Student();
	}
}

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

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

通过package关键字+【空格】+包名;[首行]

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

方便管理java类，区分名称相同的java类/接口。

5.6.java中包的具体用法？

import 包名+类名/*；【次行】

例如:

import com.wangxing.extendsdemo1.Person;

在当前类中导入“ com.wangxing.extendsdemo1”中的Person类

import com.wangxing.extendsdemo1.*;

在当前类中导入“ com.wangxing.extendsdemo1”中的所有类

java.lang包不需要导入。

5.7.java中的访问限制修饰符的区别和用法？

Java中有四种权限修饰符，public【公共的】/protected【受保护的】/default【缺省的/友好的】/private【私有的】

Java类--public【任何位置，不用担心跨包】/ default【缺省的/友好的】【跨包不能访问】

Java类中的成员变量---public，protected，default【缺省的/友好的】，private

Java类中的方法---------public，protected，default【缺省的/友好的】，private

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

package com.wangxing.extends2;

public class Test1 {
	//创建四种修饰符修饰的实例变量
		public String public_bianliang="public变量";
		       String quesheng_bianliang="缺省的变量";
		protected String protected_bianliang="protected变量";	
		private	String private_bianliang="private";
		
		//测试在同一个类中的4中访问限制修饰符
		//同一个类中全部可以访问
		public void method1(){
			System.out.println(public_bianliang);
			System.out.println(quesheng_bianliang);
			System.out.println(protected_bianliang);
			System.out.println(private_bianliang);
		}
}

package com.wangxing.extends2;

public class Test2 {
			Test1 t1=new Test1();
		//同包不同类访问4中修饰符修饰的变量
		//同一个包中的子类不能访问private修饰的私量
		public void method2(){
			System.out.println(t1.public_bianliang);
			System.out.println(t1.quesheng_bianliang);
			System.out.println(t1.protected_bianliang);
			//System.out.println(t1.private_bianliang); 
		}
}

package com.wangxing.extends2;

public class TestMain {

	public static void main(String[] args) {
		/*
		//测试在同一个类中的4中访问限制修饰符
		//同一个类中全部可以访问
		Test1 t1=new Test1();
		t1.method1();
		*/
		//同包不同类访问4中修饰符修饰的变量
		//同一个包中的子类不能访问private修饰的私量
		Test2 t2=new Test2();
		t2.method2();

	}

}

以下测试的是不同包之间的访问限制

package com.wangxing.extend3;
	//创建一个不同包的子类，父类是extend2包中的Test1
	//测试在不同一个包中的子类中对4中访问限制修饰符
	//不同一个包中的子类不能访问private，缺省的修饰的变量、方法
import com.wangxing.extends2.Test1;
public class Test3 extends Test1{
	public void method3(){
		System.out.println(public_bianliang);
		//System.out.println(quesheng_bianliang);
		System.out.println(protected_bianliang);
		//System.out.println(private_bianliang);
	}

}

package com.wangxing.extend3;
import com.wangxing.extends2.Test1;
public class Test4 {
	//测试不同包不同类四种修饰符的使用
	//不同包不同类只有public修饰符可以 使用
	Test1 t4=new Test1();
	public void method5(){
		System.out.println(t4.public_bianliang);
		//System.out.println(t4.quesheng_bianliang);
		//System.out.println(t4.protected_bianliang);
		//System.out.println(t4.private_bianliang);
	}
}

package com.wangxing.extend3;

public class Main {
		//测试在不同一个包中的子类中对4中访问限制修饰符
		//不同一个包中的子类不能访问private，缺省的修饰的变量、方法
	public static void main(String[] args) {
		Test3 t3=new Test3();
		t3.method3();
		//测试不同包不同类四种修饰符的使用
		//不同包不同类只有public修饰符可以 使用
		Test4 t5=new Test4();
		t5.method5();

	   }
}

5.8.Java中子类的继承性

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

2.同一个包中子类可以继承父类中除过private修饰的变量/方法。

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

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

5.9.成员变量的隐藏

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

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

例如：

package com.wangxing.test1;
//Person父类
public class Person {
	public char name='A';
	public void method1(){
		String name="zhangsan";
		System.out.println("name=="+name);
		//如果需要输出被隐藏的成员变量，就用"this.";
		System.out.println("name=="+this.name);
	}	

}

package com.wangxing.test1;
//Person子类
public class Person2 extends Person {
		public String name="lisi";
	public void method2(){
		System.out.println("name=="+name);
		//如果需要输出父类中的成员变量，则用"super."
		System.out.println("name=="+super.name);
	}
}

package com.wangxing.test1;

public class PersonMain {

	public static void main(String[] args) {
		System.out.println("第一种成员变量的隐藏");
		Person p1=new Person();
		p1.method1();
		
		System.out.println("第二种成员变量的隐藏");
		Person2 p2=new Person2();
		p2.method2();
	}

}

5.10.什么是方法重写？

方法重写：在子类中某一个方法与父类中的某一个方法相同，此时就是子类重写父类的方法。【被子类重写的方法一定是能够被子类继承】

例如:

package com.wangxing.chongxie;

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

package com.wangxing.chongxie;

public class Student extends Person{
	public  void info() {
		 System.out.println("子类Student类重写父类的info实例方法");
		//如果强制使用被重写的父类方法
		  super.info();
	}
}

package com.wangxing.chongxie;

public class TestMain {

	public static void main(String[] args) {
		Student  stu=new Student();
		stu.info();

	}

}

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

方法重载	方法重写
同一个类中	子类中
方法名称相同	方法名称相同
方法参数不同	方法参数相同
与方法返回值类型无关	方法返回值类型相同
	强制使用被重写的父类方法super.方法