本文探讨了Java中类与类之间的继承关系，包括单继承特点、通过extends实现继承的方法、子类构造过程中的super调用，以及访问限制修饰符、成员变量隐藏、方法重写等概念。同时讲解了包的使用和java类的默认继承。
类与类之间有没有关系？
如果有这种关系是什么？
这种关系有什么特征？
1.继承
类与类之间有关系，这种关系就是继承。
继承就是通过现有的类构建出新类的机制。
现有的类叫父类【超类】，构建出来的新类叫子类
类与类之间的继承关系是单继承，一个java类只能有一个父类。
2.如何完成一个继承关系？
通过extends关键字实现继承
格式: public class 子类名称 extends 父类名称{}
class 子类名称 extends 父类名称{}
前提是父类一定是存在的。
public class Person {}
public class Student extends Person{}
3.子类对象创建过程
子类对象创建--子类的构造方法中会默认调用父类的无参数构造方法【没有父就没有子】
子类的构造方法中,如果一定要访问父类有参数的构造方法，就需要在子类的构造方法中的第一行通过“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("子类无参数的构造方法");
}
父类：
public class Person {
public Person(){
System.out.println("父类无参数构造方法");}
public Person(String name){
System.out.println("父类有参数构造方法，参数name=="+name);}
}
子类：
public class Student extends Person{
public Student(){
//super();//父类无参数构造方法
//子类的构造方法中,如果一定要访问父类有参数的构造方法
//就需要在子类的构造方法中的第一行通过“super(参数值)”
super("zhangsan");
System.out.println("子类无参数的构造方法");
}
}
测试：
package com.wangxing.test3;
public class Main1 {
public static void main(String[] args) {
//测试子类的构造方法
new Student();
}
}
总结：创建子类对象需要子类的构造方法，通过子类构造方法创建子类对象是默认会调用父类的无参数构造方法，当父类没有无参数构造方法时，我们应该在子类的构造方法中的第一行通过super（参数），调用父类有参数的构造方法来完成子类对象的创建。
4.关于java包
java包--java程序包
java中如何创建一个包？
通过package关键字创建包
格式: package 包名称; [类的第一行]
java中包的作用是什么？
区分名称相同的Java类
我们在使用java类的时候需要先导入这个java类所在的包。
怎们导包？
通过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【私有的】
例如：同一个类，同一个包
package com.wangxing.test4;
public class TestClass {
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);
}
}
public class OtherClass {
public void testMehtod1(){
TestClass tc=new TestClass();
System.out.println("publicBL=="+tc.publicBL);
System.out.println("queshengBL=="+tc.queshengBL);
System.out.println("protectedBL=="+tc.protectedBL);
//System.out.println("privateBL=="+tc.privateBL);
}
}
public class TestSunClass extends TestClass{
public void testMethod1(){
System.out.println("publicBL=="+publicBL);
System.out.println("queshengBL=="+queshengBL);
System.out.println("protectedBL=="+protectedBL);
//System.out.println("privateBL=="+privateBL);
}
}
测试：
public class Main1 {
public static void main(String[] args) {
OtherClass tc1=new OtherClass();
tc1.testMehtod1();
TestSunClass tc2=new TestSunClass();
tc2.testMethod1();
}
不同包中的类
package com.wangxing.test5;
import com.wangxing.test4.TestClass;
public class OtherClass {
public void testMethod1(){
TestClass tc=new TestClass();
System.out.println("publicBL=="+tc.publicBL);
//System.out.println("queshengBL=="+tc.queshengBL);错误
//System.out.println("protectedBL=="+tc.protectedBL);错误
//System.out.println("privateBL=="+tc.privateBL);错误
}
不同包中的子类：
package com.wangxing.test5;
import com.wangxing.test4.TestClass;
public class TestSunClass extends TestClass{
public void testMethod1(){
System.out.println("publicBL=="+publicBL);
//System.out.println("queshengBL=="+queshengBL);错误
System.out.println("protectedBL=="+protectedBL);
//System.out.println("privateBL=="+privateBL);错误
}
}
6.java中子类的继承性
1.java中的类是单继承。【一个java类只能继承一个父类】
2.同一个包中子类可以继承父类中除过private修饰的变量/方法。
3.不同包中的子类可以继承父类中public/protected修饰的变量/方法。
4.子类中的变量和方法，有一部分是子类从父类继承的，还有一部分是子类自己创建。
5.定义的java类如果没有明确的继承某个类，那么这个类默认继承了 java.lang.Object类。
【一切皆对象】
7.成员变量的隐藏
1.在同一个类中，局部变量的名称与某一个成员变量的名称相同
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.在子类中的某一个成员变量的名称与父类某一个成员变量的名称相同
public class Person {
//成员变量
public String name="person";
}
public class SunClass extends Person{
//成员变量
public char name='好';
public void testMethod(){
System.out.println("name=="+name); //好 [成员变量的隐藏]
//需要强制使用被隐藏的成员变量，super访问
System.out.println("name=="+super.name); //person
}
}
SunClass sc1=new SunClass();
sc1.testMethod();
8.方法重写
在子类中某一个方法与父类中的某一个方法相同，此时就是子类重写父类的方法。
父类：
public class Person {
//成员变量
public String name="person";
public void testInfo(){
System.out.println("Person的实例方法");
}
}
public class SunClass extends Person{
//成员变量
public char name='好';
public void testMethod(){
System.out.println("name=="+name); //好 [成员变量的隐藏]
//需要强制使用被隐藏的成员变量，super访问
System.out.println("name=="+super.name); //person
}
//方法重写
public void testInfo(){
System.out.println("SunClass的实例方法");
}
测试类：
public class Main1 {
public static void main(String[] args) {
SunClass sc1=new SunClass();
sc1.testMethod();
sc1.testInfo();
}
}
473
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
