java中的子类与继承

最新推荐文章于 2023-05-16 11:58:51 发布
最新推荐文章于 2023-05-16 11:58:51 发布
阅读量1k 收藏 11
点赞数
文章标签： java 继承 子类 方法重写
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y1356998843/article/details/95317749
版权

子类与父类：

       多个类中具有相同的属性和行为时，将这些内容拿出来单独放到一个类中，其他多个类无需再定义这些属性和行为，只需要         继承这个类即可。单独的这个类称为父类，基类或超类。多个类被称为子类或者派生类。继承以后，可以在父类的基础上加         入自己的新成员。

继承：

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

       好处：

             1.提高了代码的复用性。

              2.提高了代码的维护性。

              3.让类与类之间有了关系，是多态的前提。（同时也是弊端，增强了类的耦合性）

      弊端：

               增强了类的耦合性。

               开发原则：低耦合，高内聚。

                        耦合：类与类的关系。

                        内聚：自己完成某项事情的能力。

使用继承之前：

package Person;

public class Student {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}
package Person;

public class Soldier {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}
package Person;

public class ExtendsDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//学生
		Student s = new Student();
		s.eat();
		s.sleep();
		
		//军人
		Soldier s2 = new Soldier();
		s2.eat();
		s2.sleep();
	}

}

使用继承之后：

package Person;

public class Person {
	public void eat() {
		System.out.println("吃饭");
	}
	
	public void sleep() {
		System.out.println("睡觉");
	}
}

package Person;

public class Student extends Person {

}
package Person;

public class Soldier extends Person {
	
}
package Person;

public class ExtendsDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//学生
		Student s = new Student();
		s.eat();
		s.sleep();
		
		//军人
		Soldier s2 = new Soldier();
		s2.eat();
		s2.sleep();
	}

}

    特点：

            1.java中只支持单继承，不支持多继承。（其他语言有的支持多继承，例如C++，格式extends 父类1，父类2，.....）

            2.支持多层继承（形成继承体系）。

            3.子类只能继承父类中的非私有成员，但可以通过父类的成员方法调用父类的私有成员变量。

            4.子类不能继承父类的构造方法，但可以通过super关键字访问父类的构造方法。

 

多层继承：

package GrandFather;

public class GrandFather {
	public void show() {
		System.out.println("GrandFather");
	}
}
package GrandFather;

public class Father extends GrandFather {
	public void method() {
		System.out.println("Father");
	}
}

package GrandFather;

public class Son extends Father {
	public void show2() {
		System.out.println("Son");
	}
}
package GrandFather;

public class ExtendsDemo1 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Son s = new Son();
		s.show();
		s.method();
		s.show2();
	}
}

 

怎样判断是否使用继承：

                 采用假设法：如果有两个类A，B，只有当A是B的一种或者B是A的一种的时候，就可以考虑使用继承。

                  注意：不要为了部分功能而去继承。

package Number;

public class Father {
	int num1 = 100;
	int num2 = 200;
	
	public void Number() {
		System.out.println(num1);
		System.out.println(num2);
	}
}
package Number;

public class Son {
	int num2 = 200;
	int num3 = 400;
	
	public void Number1() {
		System.out.println(num2);
		System.out.println(num3);
	}
}
package Number;

public class ExtendsDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Son s = new Son();
		s.Number1();
		
		Father s1 = new Father();
		s1.Number();
		
		
	}

}
package Number;

public class Son extends Father {//虽然继承了num2但是多了num1
	int num2 = 200;
	int num3 = 400;
	
	public void Number1() {
		System.out.println(num3);
	}
}
package Number;

public class ExtendsDemo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
        //输出结果多了num1
		Son s = new Son();
		s.Number();
		s.Number1();
		
	}

}

 

 

     继承中父类成员变量与子类成员变量之间的关系：

                  子类成员变量与父类成员变量名相同：（就近原则）

                          1.首先在子类的局部范围查找。

                           2.然后在子类的成员范围查找。

                           3.最后在父类的成员范围内查找，这里不考虑多层继承的情况。（不可能访问到父类的局部范围）。

                           4.如果都没有，报错。

    继承中构造方法之间的关系：

                           1.子类构造方法默认访问父类构造方法。（因为子类会继承父类的数据，可能还会使用父类的数据， 所以子类                                  初始化之前，一定要先完成父类的初始化）。

                           2.子类的构造方法的第一条默认语句为super（）；

package Father;

public class Father {
	public Father() {
		System.out.println("Father无参构造方法");
	}
	
	public Father(String name) {
		System.out.println("Father的有参构造方法");
	}
}
package Father;

public class Son extends Father {
	public Son() {
		//子类的构造方法中第一句默认为super();
		System.out.println("Son的无参构造方法");
	}
	
	public Son(String name) {
		//子类的构造方法中第一句默认为super();
		System.out.println("Son的有参构造方法");
	}
}
package Father;

public class ExtendsDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Son s = new Son();
		System.out.println("-----------");
		Son s2 = new Son("周杰伦");
	}

}

 

                           3.如果父类没有无参构造方法；

                                            解决方法：

                                                      1.在父类中加一个无参构造方法。

                                                      2.通过super调用父类的有参构造方法。

                                                      3.通过this访问本类的其他构造方法（被访问的方法中必须要访问了父类的构造方                                                                               法，否则父类数据就没有初始化）。

                                                注意：this（....）或则super(.....)必须出现在第一条语句上。如果不是在第一条语句上，就可能对                                                               父类进行了多次初始化。

通过super访问父类的有参构造方法：

package Father;

public class Father {
	public Father(String name) {
		System.out.println("Father的有参构造方法");
	}
}
package Father;

public class Son extends Father {
	public Son() {
		super("雷锋");
		System.out.println("Son的无参构造方法");
	
	}
	public Son(String name) {
		super("雷锋");
		System.out.println("Son的有参构造方法");
	}
}

 

通过this访问本类中的其他构造方法：

package Father;

public class Son extends Father {
	public Son() {
		super("雷锋");
		System.out.println("Son的无参构造方法");
	
	}
	public Son(String name) {
		this();//通过this访问本类中的其他构造方法，被访问的构造方法中必须访问了父类的构造方法。
		System.out.println("Son的有参构造方法");
	}
}

 

继承中成员方法之间的关系：

                    子类中方法声明和父类中方法声明一样的使用：

                                 通过子类对象访问一个方法：（就近原则）

                                    1.先找子类中看有没有这个方法。有就使用。

                                     2.然后找父类中看有没有这个方法。有就使用。（这里不考虑多层继承）。

                                    3.如果都没有，就报错。

package Father;

public class Father {
	public void show() {
		System.out.println("Father的成员方法");
	}
}
package Father;

public class Son extends Father {
	public void show() {
		System.out.println("Son的成员方法");
	}
}

package Father;

public class ExtendsDemo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Son s = new Son();
		s.show();//就近原则，运行结果为：Son的成员方法。
	}
}

 

                   方法重写：（override）

                            概述：子类中出现了和父类声明一模一样的方法声明，也被称为方法覆盖或则方法复写。

                            特点：如果方法名不同，有就调用对应的方法。如果方法名相同，最终使用的是子类自己的。

                            应用：当子类需要父类中的功能，而子类又需要有自己的特有的内容时，可以重写父类的方法，这样既沿袭了                                         父类的功能，又定义了子类特有的功能。

                            注意：

                                    1.父类中的私有方法不能被子类重写。

                                    2.父类中的静态方法在子类中重写时也要用静态方法（其实这个不算严格意义上的方法重写）。

                                    3.子类重写父类时访问权限不能降低，只能大于等于。（子类重写父类方法时声明最好一模一样）。

                方法重载：（overload）

                             概述：同一个类中出现的方法名相同，参数列表不同的现象。

                             注意：方法重载能改变返回值的类型，因为它和返回值类型无关。

方法重写：

 

package Phone;

public class Phone {
	public void show() {
		System.out.println("打电话");
	}
}

package Phone;

public class NewPhone extends Phone {
	public void show() {
		super.show();//方法重写之后用super访问父类的方法
		System.out.println("玩游戏");
	}
}
package Phone;

public class ExtendsDemo4 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		NewPhone s = new NewPhone();
		s.show();
	}

}

 

香樟依旧
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA子类与继承实验报告
06-30
JAVA子类与继承实验报告 实验1 中国人与美国人 实验2 面积之和
C++课后习题第四章
lornaleo的博客
01-11 927
第四章——派生类和继承作业 一、单选题（共20题，100分） 1.有如下类定义： class Father{ //基类 public: Father(string s):name(s) { } private: string name; }; class Mother{ //基类 public: Mother(string s):name(s) { } private: string name; }; 【1】...
java字类与继承
最新发布
weixin_51884452的博客
05-16 810
java字类和继承
关于Spring中Controller的继承问题
7zwang的博客
10-27 6968
关于Spring中Controller的继承问题
继承和泛型的子类重写方法问题
baidu_34932610的博客
08-05 1678
项目中出现问题复现，抽象父类的方法调用自己的非抽象方法，如果使用子类想要扩展该抽象方法，参数不能为继承实体类型，会导致子类无法重写父类方法： 1.实体父类 package exOne; public class BaseEntity { private String name; private String code; public String getName() { return name; } public void setName(String name) { this
java子类的继承性
weixin_56989099的博客
04-24 773
public 公共的 private 私有的 protected 保护的 友好变量和友好方法：除public、private、protected 修饰的变量和方法 子类与父类在同一个包下 则能继承除private的成员变量和成员方法。 子类和父类不在同一个包下 则能继承public、protected的方法和变量，不能继承友好方法和变量。 对于多重继承的子类 例如：Father、Son、GrandSon package Test1; public class Fa
Java子类的继承性
12-22
　如果子类和父类不在同一个包中，那么子类继承了父类的protected、public成员变量作为子类的成员变量，并且继承了父类的protected、public方法，继承的成员或方法的访问权限保持不变，但子类不能继承父类的友好...
java子类的继承代码实例讲解
10-19
类的继承是在现有类的基础上去构建新的类，构建的新类被称为子类，子类会自动拥有父类所有可继承的属性和方法 使用方法：想要声明一个子类，需要使用extends关键字 语法格式： 【修饰符】 class 子类名 extends 父类...
Java 限制子类访问的方法分析
08-25
主要介绍了Java 限制子类访问的方法,结合实例形式分析了java类的继承与访问相关操作技巧与使用注意事项,需要的朋友可以参考下
java-employeeSubClass:使用Java尝试子类和继承
03-15
employeeSubClass
java的子类与继承
qq_73063535的博客
05-15 72
即。
Java子类与继承（考试必备）
AQIANKE的博客
11-18 970
所谓方法重写，是指子类中定义一个方法，这个方法的类型和父类的方法的类型 一致或者是父类的方法的类型的子类型（所谓子类型，是指如果父类的方法的类型是“类”， 允许子类的重写方法的类型是“子类”)，并且这个方法的名字、参数个数、参数的类型和父 的方法完全相同。子类如此定义的方法称作子类重写的方法。如果子类和父类在同一个包中，那么子类自然地继承了其父类中不是private的成员变量作为自己的成员变量，并且也自然地继承了父类中不是private的方法作为自己的方法，继承的成员变量或方法的访问权限保持不变。
【Java子类与继承（完整版）】
lflcodeplus的博客
03-27 7695
Java子类与继承1 子类与父类1.1 子类1.2 类的树形结构2 子类的继承性2.1 子类和父类在同一包中的继承性2.2 子类和父类不在同一包中的继承性2.3 继承关系（Generalization）的UML图2.4 protected的进一步说明3 子类与对象3.1 子类对象的特点3.2 关于instanceof运算符4 成员变量的隐藏和方法重写4.1 成员变量的隐藏4.2 方法重写5 super关键字二级目录6 final关键字二级目录7 对象的上转型对象二级目录8 继承与多态二级目录9 abstra
Java进阶（三十一）泛型2
qq_33491651的博客
02-28 135
3.自定义泛型结构 4.泛型在继承上的提现 5.通配符的使用 6.泛型应用举例
Java 类的继承与应用
listen020的博客
12-12 426
在Java中，继承指的是一种面向对象的编程技术，它允许一个类（子类）获得另一个类（父类）的属性和方法。这样，子类就能够继承父类的所有属性和方法，而无需重新定义或实现它们。 继承的主要优点有以下几点： 继承可以减少代码冗余，提高代码复用率。 继承可以提高程序的扩展性和可维护性。 继承可以清晰地表示类与类之间的关系。
用Java语言在eclipe当中实现父类与子类的应用【示例1】
张小鱼的博客
10-31 737
先展示一下题目要求 由上述问题可以总结出来父类的属性是工作名称，父类的方法是工作描述；对于子类Testwork类来说，属性是编写的测试用例个数，还有发现的bug数，以及重写的工作描述；对于子类Developmentwork类来说，属性是有效编码行数和未解决的bug数，方法为重写的工作描述。 以下是父类的定义【特别注意：必须是在你已经建的包下面创立work父类以及子类】 public class Work { public String workname;//工作名称 //alt+sh..
jav笔记之子类与继承
weixin_51976923的博客
10-28 1011
java子类与继承，超详细笔记！必读好文！
Java学习笔记04——子类与继承
qq_45033269的博客
02-26 792
用abstract关键字修饰的方法称为abstract方法（抽象方法），抽象方法只允许声明，不允许实现（没有方法体）。同时不能使用static或final关键字修饰抽象方法。用abstract关键字修饰的类称为abstract类（抽象类）。. . . }允许抽象类拥有抽象方法（其他类中不能有抽象方法），也允许拥有非抽象方法。不能使用new运算符创建抽象类的对象。如果某个非抽象类是抽象类的子类，则其必须重写父类的抽象方法，给出方法体。
Java基础学习——Java面向对象（五）继承、重写
skx1102195517的博客
10-27 1424
一
java子类可以继承父类哪些内容
03-27
Java子类可以继承父类的以下内容： 1. 属性：包括公共、私有和受保护的属性。 2. 方法：包括公共、私有和受保护的方法。 3. 构造函数：子类继承了父类的构造函数，但不能直接调用父类的构造函数，需要通过super关键字调用。 4. 内部类：如果父类中有内部类，子类也可以继承它们。 5. 接口：子类可以实现父类实现的接口。 6. 常量：子类可以继承父类中的常量。 需要注意的是，子类不能继承父类中的私有构造函数和私有方法。同时，子类可以通过重写父类的方法来改变其行为。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值