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

最新推荐文章于 2024-06-25 07:59:20 发布

2401_84558091

最新推荐文章于 2024-06-25 07:59:20 发布

阅读量877

点赞数 26

分类专栏：程序员文章标签： java 学习经验分享

本文链接：https://blog.csdn.net/2401_84558091/article/details/139156148

版权

程序员专栏收录该内容

131 篇文章 0 订阅

订阅专栏

this关键字由来和使用:

this:代表所在类的对象引用。
方法被哪个对象调用，this就代表那个对象。
局部变量和成员变量重名的时候使用this。

继承

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

简介

面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。

介绍：

通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。

在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。

继承概念的实现方式有三类：实现继承、接口继承和可视继承。

实现继承是指使用基类的属性和方法而无需额外编码的能力；
接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。

在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。

抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。

继承的格式&使用

在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

格式：

class 子类 extends 父类 {}

package com.itxbj_01;

继承：多个类有共同的成员变量和成员方法，抽取到另外一个类中（父类），在让多个类去继承这个父类，我们的多个类就可以获取到父类中的成员了。
extends

public class ExtendsDemo {

public static void main(String[] args) {

DotA1 d = new DotA1();

d.start();

LOL1 l = new LOL1();

l.start();

}

class Game1 {

String name;

double version;//版本号

String agent;//代理商

public void start() {

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

}

public void stop() {

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

}

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

必看视频！获取2024年最新Java开发全套学习资料备注Java

的子类

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;

多态的成员特点:

总结

总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。

如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。

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;

多态的成员特点:

总结

[外链图片转存中…(img-KEtXcQkK-1716464365649)]

2401_84558091

关注

26
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
Java程序设计（面向对象）- 三大支柱

总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。/*多态的前提：子父类的继承关系方法的重写父类引用指向子类对象。
复制链接

扫一扫