Java程序设计（面向对象）- 三大支柱，java面试业务场景实现

最新推荐文章于 2024-06-25 13:57:58 发布

2401_84411593

最新推荐文章于 2024-06-25 13:57:58 发布

阅读量395

点赞数 3

分类专栏： 2024年程序员学习文章标签： java 面试 python

本文链接：https://blog.csdn.net/2401_84411593/article/details/137916864

版权

2024年程序员学习专栏收录该内容

49 篇文章 0 订阅

订阅专栏

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

s.show();

s.name = “林青霞”;

//s.age = 28;

//s.age = -28;

//s.setAge(-28);

s.setAge(28);

s.show();

}

封装的概述和好处:
封装概述

是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。

封装原则：

将不需要对外提供的内容都隐藏起来。

把属性隐藏，提供公共方法对其访问。

成员变量private，提供对应的getXxx()/setXxx()方法。

好处：

通过方法来控制成员变量的操作，提高了代码的安全性。

把代码用方法进行封装，提高了代码的复用性。

this关键字

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的子类

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 子类类型();

变量名.方法名();

最后

学习视频：

大厂面试真题：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
er.method();

System.out.println(this.num);

}

继承优缺点

优点:

提高了代码的复用性
提高了代码的可维护性

缺点：

类的耦合性增强了
开发的原则：高内聚低耦合
内聚：就是自己完成某件事情的能力
耦合：类与类的关系

多态

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

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

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

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

多态的定义与使用格式

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

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

变量名.方法名();

最后

学习视频：

[外链图片转存中…(img-t9ixc3nD-1713416103853)]

大厂面试真题：

[外链图片转存中…(img-056Ok915-1713416103853)]

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-qipUNb1c-1713416103854)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

2401_84411593

关注

3
点赞
踩
6

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录