Java基础07面向对象，2024年最新java面试题

显然现实中并不存在999这样的年龄，那么我们便可以通过封装来规避不合法的操作：

public class Student {

//属性私有

private String name;//姓名

private int id;//学号

private char sex;//性别

private int age;//年龄

public int getAge() {

return age;

}

public void setAge(int age) {

if (age < 120 && age > 0){

this.age = age;

}else {

System.out.println(“输入的年龄不合法！”);

}

}

}

只有当输入的年龄符合程序要求时才会正常输出

封装的意义

• 提高程序的安全性，保护数据

• 隐藏代码实现细节

• 统一接口，实现规范

• 提高系统可维护性

继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

• extands的意思是“扩展”。子类是父类的扩展。

• JAVA中类只有单继承，没有多继承。（一个儿子只能有一个爸爸，但一个爸爸可以有多个儿子）

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

• 继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示。

• 子类和父类之间，从意义上讲应该具有"is a"的关系。

子类继承父类，就会拥有父类的全部方法（私有的无法被继承）：

public class Person {

public void say(){

System.out.println(“说了一句话”);

}

}

public class Student extends Person{

public static void main(String[] args) {

Student student = new Student();

student.say();

}

}

在Student类中可以调用say()方法，因为Student继承了Person类，故拥有Person类的所有方法。

在Java中，所有的类都默认直接或间接继承Object

super

this指向当前类，super指向父类

例：

父类：

public class Person {

protected String name = “小明”;

}

子类：

public class Student extends Person{

protected String name = “小红”;

public void test(String name){

System.out.println(name);

System.out.println(this.name);

System.out.println(super.name);

}

}

测试类：

public class Application {

public static void main(String[] args) {

Student student = new Student();

student.test(“小强”);

}

}

第一行输出“小强”是因为在测试类中，我们调用了test方法，传递了一个参数“小强”

第二行输出“小红”是因为“this.name”指向当前类（Student类）的私有变量name，其值为“小红”

第三行输出“小明”是因为super指向父类（Person类）的name变量，而父类的name值为“小明”

关于继承中调用无参构造器的顺序，我们可以举如下例子：

//父类

public class Person {

public Person(){

System.out.println(“Person父类的无参构造”);

}

}

//子类

public class Student extends Person{

public Student(){

System.out.println(“Student子类的无参构造”);

}

}

//测试类

public class Application {

public static void main(String[] args) {

Student student = new Student();

}

}

由此可见，在继承时，默认调用且先调用父类的无参构造。调用父类的构造器必须放在子类构造器的第一行。

super注意点：

• super调用父类的构造方法，必须在构造方法的第一行

• super必须只能出现在子类的方法或者构造方法中

• super和this不能同时调用构造方法

• super代表父类对象的引用，而this代表本身调用者的对象

• super只能在继承条件下才可以使用，this没有继承也可以使用

• super()：父类的构造；this()：本类的构造

方法的重写

先看静态方法：

//父类

public class B {

public static void test(){

System.out.println(“B=>test”);

}

}

//子类

public class A extends B{

public static void test(){

System.out.println(“A=>test”);

}

}

import com.oop.demo05.A;

import com.oop.demo05.B;

//测试类

public class Application {

public static void main(String[] args) {

A a = new A();

a.test();

//父类的引用指向了子类

B b = new A();

a.test();

}

}

方法的调用只和左边定义的数据类型有关，和new A()还是new B()没有关系

父类的引用指向了子类

到非静态方法时：

//父类

public class B {

public void test(){

System.out.println(“B=>test”);

}

}

//子类

public class A extends B{

//Override 重写

@Override//注解，有功能的注释

public void test() {

System.out.println(“A=>test”);

}

}

import com.oop.demo05.A;

import com.oop.demo05.B;

//测试类

public class Application {

public static void main(String[] args) {

A a = new A();

a.test();

B b = new A();//子类重写了父类的方法

b.test();

}

}

子类重写了父类的方法。

重写需要有继承关系，子类重写父类的方法

• 方法名必须相同

• 参数列表必须相同

• 修饰符：范围可以扩大，但不能缩小

public>Protected>Default>private

• 抛出的异常范围可以被缩小但不能被扩大

• 重写 子类的方法和父类必须一致，方法体不同

• 为什么需要重写？

子类不一定需要或不一定满足父类的功能

多态

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

• 多态存在的条件：

有继承关系

子类重写父类方法

父类引用指向子类对象

• 注意：多态是方法的多态，属性没有多态性。

一个对象的实际类型是确定的，但可以指向的引用类型就不确定了：

//父类

public class Person {

public void run(){

System.out.println(“快跑”);

}

}

//子类

public class Student extends Person{

}

import com.oop.demo06.Person;

import com.oop.demo06.Student;

//测试类

public class Application {

public static void main(String[] args) {

//一个对象的实际类型是确定的

//new Student();

//new Person();

//但可以指向的引用类型就不确定了

//父类的引用指向子类

Student s1 = new Student();

Person s2 = new Student();

Object s3 = new Student();

s2.run();

s1.run();

}

}

当在子类中重写run()方法时：

//子类

public class Student extends Person{

@Override

public void run() {

System.out.println(“子类=>快跑”);

}

}

若在子类中定义eat()方法：

//子类

public class Student extends Person{

@Override

public void run() {

System.out.println(“子类=>快跑”);

}

public void eat(){

System.out.println(“吃”);

}

}

父类无法调用eat()方法：

多态注意事项：

多态是方法的多态，属性没有多态

存在条件：有继承关系，方法需要重写！

子类能调用的方法都是自己的或者父类的

父类可以指向子类，但是不能调用子类独有的方法

抽象类

• abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

• 抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。

• 抽象类，不能使用new关键字来创建对象，它是用来让子类继承的。

• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。

• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。

接口的定义与实现

• 普通类：只有具体实现

• 抽象类：具体实现和规范(抽象方法)都有

• 接口：只有规范(自己无法写方法)(约束和实现分离：面向接口编程)

• 接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能.….”的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人；如果你是坏人，则必须欺负好人。

• 接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。

• 面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。

要实现接口里的所有定义，必须重写接口中的所有方法

//接口

public interface UserService {

//接口中的所有定义都是抽象的public abstract

void add(String name);

void delete(String name);

void update(String name);

void query(String name);

}

//类 可以实现接口 implements 接口

//实现了接口的类，就需要重写接口中的方法

public class UserServiceImpl implements UserService{

@Override

public void add(String name) {

}

@Override

public void delete(String name) {

}

@Override

public void update(String name) {

}

@Override

public void query(String name) {

}

}

类可以实现多个接口：

再定义一个接口：

//接口TimeService

public interface TimeService {

void timer();

}

//类 可以实现接口 implements 接口

//实现了接口的类，就需要重写接口中的方法

//可利用接口实现多继承

public class UserServiceImpl implements UserService,TimeService{

@Override

public void add(String name) {

}

@Override

public void delete(String name) {

}

@Override

public void update(String name) {

}

@Override

public void query(String name) {

}

@Override

public void timer() {

}

}

内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

成员内部类

//外部类

public class Outer {

private int id;

public void out(){

System.out.println(“这是外部类的方法”);

}

//内部类

public class Inner{

public void in(){

System.out.println(“这是内部类的方法”);

}

}

}

import com.oop.demo10.Outer;

//测试类

public class Application {

public static void main(String[] args) {

//先new一个外部类

Outer outer = new Outer();

//通过外部类来实例化内部类

Outer.Inner inner = outer.new Inner();//这就是成员内部类

inner.in();

}

}

内部类可以获得外部类的私有属性：

//外部类

public class Outer {

//在外部类里定义id

private int id = 10;

public void out(){

System.out.println(“这是外部类的方法”);

}

//内部类

public class Inner{

public void in(){

System.out.println(“这是内部类的方法”);

}

//获得外部类的私有属性

public void getID(){

//输出id

System.out.println(id);

}

}

}

import com.oop.demo10.Outer;

//测试类

public class Application {

public static void main(String[] args) {

//先new一个外部类

Outer outer = new Outer();

//通过外部类来实例化内部类

Outer.Inner inner = outer.new Inner();//这就是成员内部类

inner.in();

//能操作外部类的私有属性

inner.getID();

}

}

• Inner类定义在Outer类的内部，相当于Outer类的成员变量的位置，Inner类可以使用任意访问修饰符，如：public、private、protected等；

• Inner类中定义的test()方法可以访问Outer类中的数据，不受访问控制符的影响；

• 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象；

• 如果外部类和内部类具有相同的成员变量或方法，内部类可以直接访问内部类的成员变量或方法，但如果内部类访问外部类的成员变量或者方法时，需要使用this关键字；

public class Outer1 {

//定义外部类的成员变量

String name = “张三”;

//定义内部类

public class Inner{

String name = “李四”;

public void show(){

System.out.println(“外部类的name为：” + Outer1.this.name);

System.out.println(“内部类的name为：” + name);

}

}

public static void main(String[] args) {

Outer1 outer1 = new Outer1();

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

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

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

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

最后

经过日积月累， 以下是小编归纳整理的深入了解Java虚拟机文档，希望可以帮助大家过关斩将顺利通过面试。
由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示 。

由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！

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

或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-3fQGUsxz-1712942569119)]
[外链图片转存中…(img-QRBvyInN-1712942569119)]
[外链图片转存中…(img-HHcqc64Q-1712942569120)]
[外链图片转存中…(img-0HJTZfH3-1712942569120)]
[外链图片转存中…(img-EAkNyBHo-1712942569121)]
[外链图片转存中…(img-BMTNu15L-1712942569121)]

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

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

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-I8zFgdus-1712942569121)]

最后

经过日积月累， 以下是小编归纳整理的深入了解Java虚拟机文档，希望可以帮助大家过关斩将顺利通过面试。
由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示 。

[外链图片转存中…(img-3ueP8bW9-1712942569122)]
[外链图片转存中…(img-OKV9MOhu-1712942569122)]
[外链图片转存中…(img-u2BobxiV-1712942569122)]
[外链图片转存中…(img-NMMBcBTc-1712942569123)]
[外链图片转存中…(img-K9ttDPkX-1712942569123)]
[外链图片转存中…(img-SK1vukQ1-1712942569123)]
[外链图片转存中…(img-tkU3MCx9-1712942569124)]

由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-76b4PYZ5-1712942569124)]