安卓校招备战-JAVA

最新推荐文章于 2024-10-30 18:07:32 发布

逍遥。

最新推荐文章于 2024-10-30 18:07:32 发布

阅读量349

点赞数 2

文章标签： java 面试

原文链接：https://blog.nowcoder.net/yangwenqiang/22100

版权

JAVA

校招加油
- 一、面向对象的三大特性

校招加油

2020年春招加油，克己赶追，用俩年走别人四到七年的路。

一、面向对象的三大特性

（1）面向对象可以解释下吗？都有哪些特性？

答：面向对象是一种思想，可以将复杂问题简单化，让我们从执行者变为了指挥者。面向对象的三大特性为：封装，继承与多态。

封装：将事物封装成一个类，减少耦合，隐藏细节。保留特定的接口与外界联系，当接口内部发生改变时，不会影响外部调用方。

继承：从一个已知的类中派生出一个新的类，新类可以拥有已知类的行为和属性，并且可以通过覆盖/重写来增强已知类的能力。

多态：多态的本质就是一个程序中存在多个同名的不同方法，主要通过三种方式来实现：

通过子类对父类的覆盖来实现
通过在一个类中对方法的重载来实现
通过将子类对象作为父类对象使用来实现（向上转型）

A. 封装

每个对象都可以想象成“服务提供者”，我们是“指挥者”。例如，new出来一个新的对象，我们这时候可以获得对象的引用；这时，我们可以把这个引用看作是一个遥控器，来指挥对象完成相应的任务。

封装可以提高一个对象的内聚性，降低其耦合度；类创建者可以隐藏内部脆弱部分，不用担心客户端程序员因粗心修改该部分，减少程序bug。

Java有三个关键词在类内部设定边界：
public: 表示任何人都可以使用
private: 除类型创建者外任何人都不可使用
protected: 和private类似，区别在于继承类可以访问protected成员，但是不可访问private成员；但同包内的也可以访问。
包访问权限: 类可以访问在同一个包中其他类的成员

package me.liguojie.eg1;
 
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "小明";
        student.age = 16;
        student.printStudentAge();
 
        Student student2 = new Student();
        student2.name = "小白";
        student2.age = 120; //在这里显然小白120岁不符合逻辑
        student2.printStudentAge();
     }
}
 
class Student {
    String name;
    int age;
 
    public void printStudentAge() {
        System.out.println(name + "同学的年龄：" + age);
    }
}

我们看到小白同学的年龄120，（假设）不符合业务逻辑需要，所以我们需要做一些内部逻辑的处理。所以需要进行代码封装，将内部逻辑进行一个隐藏。

package me.liguojie.eg2;
 
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("小明");
        student.setAge(16);
        student.printStudentAge();
 
        Student student2 = new Student();
        student.setName("小白");
        student.setAge(120);
        student2.printStudentAge();
     }
}
 
class Student {
    private String name;
    private int age;
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        if (age < 0 || age > 60)
            throw new RuntimeException("年龄设置不合法");
        this.age = age;
    }
 
    public void printStudentAge() {
        System.out.println(name + "同学的年龄：" + age);
    }
}

通过将Student这个类的name和age属性私有化，只有通过公共的get/set方法才能进行访问，在get/set方法中我们可以对内部逻辑进行封装处理，外部的调用方不必关心我们的处理逻辑。

B. 继承

a. 初始化顺序

我们需要注意Java中不支持多继承，即一个类只可以有一个父类存在。另外Java中的构造函数是不可以继承的，如果构造函数被private修饰，那么就是不明确的构造函数，该类是不可以被其它类继承的，具体原因我们可以先来看下Java中类的初始化顺序：

初始化父类中的静态成员变量和静态代码块
初始化子类中的静态成员变量和静态代码块
初始化父类中的普通成员变量和代码块，再执行父类的构造方法
初始化子类中的普通成员变量和代码块，再执行子类的构造方法

b. 父类构造器

如果父类构造函数是私有（private）的，则初始化子类的时候不可以被执行，所以解释了为什么该类不可以被继承，也就是说其不允许有子类存在。当创建出一个子类对象是，该对象包含了一个父类的的子对象，这个子对象和我们用父直接创建的对象是一样的。二者的区别在于，后者来自于外部，而父类的子对象被包装在子类对象内部。

c. super的使用

如果没有默认的父类构造器，或想调用一个代参数的基类构造器，就必须用关键词super显示地便携调用父类构造器的语句，并且配以适当的参数列表：

package me.liguojie.java;

class Game{
	Game(int i) //代参数的父类构造器；如果构造器改为private会报错，可以用protected
	{
		System.out.println("Game");
	}
}

class BoardGame extends Game{
	BoardGame(int i)
	{
		super(i); //这里如果加super编译不过去
		System.out.println("BoardGame");
	}
}

public class Chese extends BoardGame{ 
	Chese() {
		super(11);
		System.out.println("Cheese");
	}
	
	public static void main(String[] args)
	{
		Chese chese = new Chese();
	}

}