Java程序设计（面向对象）- 三大支柱

于 2025-01-13 07:09:52 发布
阅读量721 收藏 8
点赞数 11
文章标签： java python 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2501_90242391/article/details/145104619
版权

}

}

class DotA1 extends Game1 {

/*String name;

double version;//版本号

String agent;//代理商

public void start() {

System.out.println(“游戏启动了”);

}

public void stop() {

System.out.println(“游戏关闭了”);

}*/

}

class LOL1 extends Game1 {

/*String name;

double version;//版本号

String agent;//代理商

public void start() {

System.out.println(“游戏启动了”);

}

public void stop() {

System.out.println(“游戏关闭了”);

}*/

}

特点

在类的继承中，需要注意一些问题，具体如下：

1、在Java中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。

class A{}

class B{}

class C extends A,B{} // C类不可以同时继承A类和B类

2、多个类可以继承一个父类，例如下面这种情况是允许的。

class A{}

class B extends A{}

class C extends A{} // 类B和类C都可以继承类A

3、在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如C类继承自B类，而B类又可以去继承A类，这时，C类也可称作A类的子类。下面这种情况是允许的。

class A{}

class B extends A{} // 类B继承类A，类B是类A的子类

class C extends B{} // 类C继承类B，类C是类B的子类，同时也是类A的子类

4、在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的这种情况中，B类是A类的子类，同时又是C类的父类

例如：

package com.itxbj_01;

/*

  • Java中继承的特点：

  •   	Java语言只支持单一继承，只能继承一个父类（一个儿子只能有一个亲爹）

  •   	Java语言支持多层继承（一个儿子可以有一个亲爹，还可以有一个亲爷爷）

*/

public class ExtendsDemo2 {

public static void main(String[] args) {

LOL l = new LOL();

l.update();

l.start();

}

}

class Game {

public void start() {

System.out.println(“游戏启动了”);

}

}

class PCGame extends Game {

public void update() {

System.out.println(“PCGame更新了”);

}

}

class MobileGame extends Game {

public void update() {

System.out.println(“MobileGame更新了”);

}

}

class LOL extends PCGame {

}

成员变量的特点

A:子类只能获取父类非私有成员

子父类中成员变量的名字不一样直接获取父类的成员变量

子父类中成员变量名字是一样的获取的是子类的成员变量

B:就近原则：谁离我近我 就用谁

如果有局部变量就使用局部变量

如果没有局部变量，有子类的成员变量就使用子类的成员变量

如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量

C: super:可以获取父类的成员变量和成员方法,用法和this是相似的

例如：

package com.itxbj_01;

/*

  • 继承中成员变量的特点

  •   子类只能获取父类非私有成员

  •   子父类中成员变量的名字不一样直接获取父类的成员变量

  •   子父类中成员变量名字是一样的获取的是子类的成员变量

  • 就近原则：谁离我近我就用谁

  •   如果有局部变量就使用局部变量

  •   如果没有局部变量，有子类的成员变量就使用子类的成员变量

  •   如果没有局部变量和子类的成员变量，有父类的成员变量就使用父类的成员变量

  •   啥都没有，出错了！！！

  • super:可以获取父类的成员变量和成员方法,用法和this是相似的

*/

public class ExtendsDemo3 {

public static void main(String[] args) {

Kid3 k = new Kid3();

k.show();

}

}

class Dad3 {

String name = “建霖”;

}

class Kid3 extends Dad3 {

String name = “四葱”;

public void show() {

String name = “五葱”;

System.out.println(super.name);

System.out.println(this.name);

System.out.println(name);

}

}

成员方法的特点&方法重写

A:子类中没有这个方法,调用父类的

例如：

package com.itxbj_01;

/*

  • 继承中成员方法的特点

  •   子类中没有这个方法，调用父类的

*/

public class ExtendsDemo4 {

public static void main(String[] args) {

Kid4 k = new Kid4();

k.eat();

}

}

class Dad4 {

public void eat() {

System.out.println(“小酌两口”);

System.out.println(“去睡觉了”);

}

}

class Kid4 extends Dad4 {

}

B: 子类中重写了这个方法，调用子类的

方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法

例如：

package com.itxbj_01;

/*

  • 继承中成员方法的特点

  •   子类中没有这个方法，调用父类的

  •   子类中重写了这个方法，调用子类的

方法的重写：在子父类当中，子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），当子类重写了父类的方法之后，使用子类对象调用的就是子类的方法

方法的重载：在一个类中，有多个重名的方法，但是其参数不一样（参数的个数，参数的类型，参数的顺序），和返回值无关

*/

public class ExtendsDemo4 {

public static void main(String[] args) {

Kid4 k = new Kid4();

k.eat();

}

}

class Dad4 {

public void eat() {

System.out.println(“小酌两口”);

System.out.println(“去睡觉了”);

}

}

class Kid4 extends Dad4 {

public void eat() {

System.out.println(“好好吃饭”);

}

}

7.6 方法重写的应用场景&注意事项

  • 方法重写的应用场景：

当父类的方法不能完全满足子类使用的时候，既可以保留父类的功能（沿袭、传承），还可以有自己特有的功能

  • 方法重写的注意事项：

不可以重写父类私有的成员方法，压根就看不到父类的私有成员

子类重写父类方法，权限必须大于等于父类方法的权限

  • 注解:

@Override：方法重写，说明下面的方法是重写父类的方法

例如：

package com.itxbj_03;

/*

  • 方法重写的应用场景：当父类的方法不能完全满足子类使用，这个时候子类重写父类的方法，

  •   		    并可以在方法中使用关键字super调用父类的方法，这样做即可以保有父类的功能，也可以拥有子类特有的功能

  • 方法重写的注意事项：

  •   	  不能重写父类私有的方法

  •   	 权限必须大于等于父类方法的权限

  • 注解：@

*/

public class ExtendsDemo5 {

public static void main(String[] args) {

NewPhone np = new NewPhone();

np.call();

}

}

class Phone {

void call() {

System.out.println(“打电话”);

}

}

class NewPhone extends Phone {

@Override

public void call() {

System.out.println(“录音”);

//System.out.println(“打电话”);

//super.call();

}

}

构造方法的执行顺序

  • super(实参列表);语句 在子类的构造方法中使用,用来调用父类中的构造方法(具体哪一个由传递的参数决定),并且只能在构造方法第一行使用

  • this(实参列表); 语句 在类的构造方法中使用,用来调用本类中的其它构造方法(具体哪一个由传递的参数决定),并且只能在构造方法的第一行使用

例如：

package com.itxbj_01;

/*

  • 继承中构造方法的执行顺序

  •   	在子父类中，创建子类对象，调用子类的构造方法，

  •   	在子类的构造方法的第一行代码如果没有调用父类的构造或者没有调用子类的其他构造，则默认调用父类无参构造

  • 为什么要调用父类构造？

  •   	因为需要给父类的成员变量初始化

  • 肯定会先把父类的构造执行完毕，在去执行子类构造中的其他代码

  • 我是父类无参构造 — 我是子类有参构造 — 我是子类无参构造

*/

public class ExtendsDemo6 {

public static void main(String[] args) {

//Die d = new Die();

Zi6 z = new Zi6();

}

}

class Die6 {

public Die6() {

System.out.println(“我是父类无参构造”);

}

public Die6(int num) {

System.out.println(“我是父类有参构造”);

}

}

class Zi6 extends Die6 {

public Zi6() {

//super(1);

//super();

this(1);//不会再调用父类的无参构造了

System.out.println(“我是子类无参构造”);

}

public Zi6(int num) {

//会默认调用父类无参构造

System.out.println(“我是子类有参构造”);

}

}

this与super区别

例如：

package com.itxbj_01;

/*

  • this和super的区别

this:当前对象的引用

调用子类的成员变量

调用子类的成员方法

在子类的构造方法第一行调用子类其他构造方法

super:子类对象的父类引用

调用父类的成员变量

调用父类的成员方法

在子类的构造方法第一行调用父类的构造方法

*/

public class ExtendsDemo7 {

public static void main(String[] args) {

Zi z = new Zi();

z.function();

}

}

class Die {

int num = 10;

public Die() {

System.out.println(“我是父类无参构造”);

}

public Die(int num) {

System.out.println(“我是父类有参构造”);

}

public void method() {

System.out.println(“我是父类的方法”);

}

}

class Zi extends Die {

//int num = 30;

public Zi() {

//this(1);//第一行不调用子类其他构造或者是父类构造，默认调用父类无参构造

super();

System.out.println(“我是子类无参构造”);

}

public Zi(int num) {

System.out.println(“我是子类有参构造”);

}

public void method() {

System.out.println(“我是子类的方法”);

}

public void function() {

//this.num = 50;

//System.out.println(num);

//this.method();

//super.num = 40;

//super.method();

System.out.println(this.num);

}

}

继承优缺点

优点:

  • 提高了代码的复用性

  • 提高了代码的可维护性

缺点：

  • 类的耦合性增强了

  • 开发的原则：高内聚低耦合

  • 内聚：就是自己完成某件事情的能力

  • 耦合：类与类的关系

多态

================================================================

多态是继封装、继承之后，面向对象的第三大特性。

现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的同学张三既是学生也是人，即出现两种形态。

Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。

多态的定义与使用格式

多态的定义格式：就是父类的引用变量指向子类对象

父类类型 变量名 = new 子类类型();

变量名.方法名();

  • 普通类多态定义的格式

父类 变量名 = new 子类();

如：

class Fu {}

class Zi extends Fu {}

//类的多态使用

Fu f = new Zi();

  • 抽象类多态定义的格式

抽象类 变量名 = new 抽象类子类();

如：

abstract class Fu {

public abstract void method();

}

class Zi extends Fu {

public void method(){

System.out.println(“重写父类抽象方法”);

}

}

//类的多态使用

Fu fu= new Zi();

  • 接口多态定义的格式

接口 变量名 = new 接口实现类();

如：

interface Fu {

public abstract void method();

}

class Zi implements Fu {

public void method(){

System.out.println(“重写接口抽象方法”);

}

}

//接口的多态使用

Fu fu = new Zi();

案例:

package com.itxbj_01;

/*

  • 多态的前提：

  • 子父类的继承关系

  • 方法的重写

  • 父类引用指向子类对象

  • 动态绑定：运行期间调用的方法，是根据其具体的类型

*/

public class PoymorphicDemo {

public static void main(String[] args) {

/*Cat c = new Cat();

c.eat();*/

//父类引用 Animal a

//指向 =

//子类对象 new Cat()

Animal a = new Cat();

a.eat();

}

}

class Animal {

public void eat() {

System.out.println(“吃东西”);

}

}

class Cat extends Animal {

public void eat() {

System.out.println(“猫吃鱼”);

}

}

多态成员的特点

  • 多态成员变量

当子父类中出现同名的成员变量时，多态调用该变量时：

编译时期：参考的是引用型变量所属的类中是否有被调用的成员变量。没有，编译失败。

运行时期：也是调用引用型变量所属的类中的成员变量。

简单记：编译和运行都参考等号的左边。编译运行看左边。

  • 多态成员方法

编译时期：参考引用变量所属的类，如果没有类中没有调用的方法，编译失败。

运行时期：参考引用变量所指的对象所属的类，并运行对象所属类中的成员方法。

简而言之：编译看左边，运行看右边

案例:

package com.itxbj_01;

/*

  • 多态的成员特点:

  •   成员变量  编译时看的是左边，运行时看的左边

  •   成员方法  编译时看的是左边，运行时看右边

  •   静态方法  编译时看的是左边，运行时看的也是左边

  • 编译时看的都是左边，运行时成员方法看的是右边，其他（成员变量和静态的方法）看的都是左边

*/

public class PoymorphicDemo2 {

public static void main(String[] args) {

Dad d = new Kid();

//System.out.println(d.num);

//d.method();

d.function();//使用变量去调用静态方法，其实相当于用变量类型的类名去调用

}

}

class Dad {

int num = 20;

public void method() {

System.out.println(“我是父类方法”);

}

public static void function() {

System.out.println(“我是父类静态方法”);

}

}

class Kid extends Dad {

int num = 10;

public void method() {

System.out.println(“我是子类方法”);

}

public static void function() {

System.out.println(“我是子类静态方法”);

}

}

多态中向上转型与向下转型

多态的转型分为向上转型与向下转型两种：

  • 向上转型：当有子类对象赋值给一个父类引用时，便是向上转型，多态本身就是向上转型的过程。

使用格式：

父类类型 变量名 = new 子类类型();

如：Person p = new Student();

  • 向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用转为子类引用，这个过程是向下转型。如果是直接创建父类对象，是无法向下转型的

使用格式：

子类类型 变量名 = (子类类型) 父类类型的变量;

如:Student stu = (Student) p; //变量p 实际上指向Student对象

案例:

package com.itxbj_01;

/*

  • 多态中的向上转型和向下转型:

  • 引用类型之间的转换

  • 向上转型

  •   由小到大(子类型转换成父类型)

  • 向下转型

  •   由大到小

  • 基本数据类型的转换

  • 自动类型转换

  •   由小到大

  •   byte short char --- int --- long --- float --- double

  • 强制类型转换

  •   由大到小

*/

public class PoymorphicDemo3 {

public static void main(String[] args) {

Animal2 a = new Dog();//向上转型

//a.eat();

Dog d = (Dog)a;//向下转型

d.swim();

}

}

class Animal2 {

public void eat() {

System.out.println(“吃东西”);

}

}

class Dog extends Animal2 {

public void eat() {

System.out.println(“啃骨头”);

}

public void swim() {

System.out.println(“狗刨”);

}

}

多态的优缺点

案例:

package com.itxbj_01;

/*

  • 多态的优缺点

  •   优点：可以提高可维护性（多态前提所保证的），提高代码的可扩展性

缺点：无法直接访问子类特有的成员

*/

public class PoymorphicDemo4 {

public static void main(String[] args) {

MiFactory factory = new MiFactory();

factory.createPhone(new MiNote());

factory.createPhone(new RedMi());

}

}

class MiFactory {

/*public void createPhone(MiNote mi) {

mi.call();

}

public void createPhone(RedMi mi) {

mi.call();

}*/

public void createPhone(Phone p) {

p.call();

}

}

2501_90242391
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值