【Java】 语言基础习题汇总 [2] 面向对象

30 面向对象的三条主线和面向对象的编程思想？

类与类的成员 ： 属性、方法、构造器、代码块、内部类、

面向对象的三大特征：封装、继承、多态【如果还有一个，那就是抽象】

关键字：this、super、abstract、interface、static、package、import、

OOP的编程思想？

- 一切皆对象，任何业务逻辑的实现封装在对象中传递和处理

31 谈谈类和对象的关系，说出你的理解？

- 类是对象的抽象，对象是类的具体实现

- 类是一个模板，对象是模板创建出的实物

32 面向对象的创建、执行、操作、哪三步？

- 编写类和类成员

- 实例化

- 调用对象的属性或者方法

33 类的方法内是否可以定义变量，是否可以调用属性？ 是否定义方法 是否调用方法？

- 可以，在方法内定义的变量是局部变量，方法的结束，意味着变量的销毁

- 可以调用属性变量，当属性变量和局部变量同名时，使用this.指代当前对象的引用，表示当前对象的变量

- 方法内不能定义方法、可以调用方法

34 什么是方法的重载？

重载Overload 是同一个类中，具有多个同名方法，它们的参数列表不一样

是实现同一功能的不同途径

如何调用确定的方法，指定方法名，和明确的参数

35 参数传递机制的具体体现？

- 基本数据类型 ，传递变量的数据值

- 引用数据类型，传递变量的地址值，包含变量的数据类型

36 成员变量 和 局部变量 在声明的位置上，是否有默认值？

- 成员变量有，是隐式赋值

- 局部变量没有

是否能用权限修饰关键字修饰？

- 成员变量4个权限修饰皆可

- 局部变量没有

内存分布的位置？

- 成员变量，引用堆空间

- 局部变量，引用栈空间

37 谈谈Return关键字

- 表示方法的结束，在方法内，return之后的语句都不再执行

- 传递返回值，根据方法声明返回类型，方法必须在return后返回一个对应类型的值，可以是表达式

38 构造器的作用？

- 创建本类的实例

- 初始化对象结构

- 重载构造器，实现初始化时注入参数

39 成员变量的赋值方式有几种？ 先后顺序？

- 默认赋值 > 显示赋值 > 构造器注入 > setter方法，或者对象调用属性赋值

40 this 关键字可用调用哪些结构

this 属性、方法、构造器、

- 指代当前对象和当前正在创建的对象

- 构造器和setter方法见名知义 ，参数和属性同名，为了区分，用this调用属性变量

41 四个权限访问修饰符是什么？ 说明权限范围

- private 指私有的、被修饰的属性、方法、构造器、只能在类的内部访问

- default 默认的，实际上是没有修饰的，被修饰的属性、方法、构造器、只能被所在的包下访问

- protected 受保护的，被修饰的属性、方法、构造器、只能被所继承的子类访问，子类允许放在不同父类的包下

- public 公开的、被修饰的属性、方法、构造器、可以被任意访问调用

42 创建Circle类，提供私有属性radius 提供对应的setter & getter方法 求圆面积

public class Circle {

    private double radius;

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public double getRoundArea(){
        return 3.14 * radius * radius;
    }

    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.setRadius( 100.5 );
        double roundArea = circle.getRoundArea();
        System.out.println(roundArea);
    }
}

43 什么是多态性？

- 指对象的多态性，对象可以多种形态 父类引用 指向 子类对象

- 调用方法时，编译看左边，运行看右边

44 一个类可以有几个父类，一个父类可有多少个子类？ 子类能直接获取父类中的结构吗？子类能获取private修饰的父类方法吗？

- 一个类只能有一个父类

- 一个父类可以被任意数量的子类继承

- 并不能直接获取，如果父类的一些成员被private修饰，那么子类是无法访问的

- 默认default权限修饰的情况，子类必须和父类同一包下才可访问

- 如果要异包访问，父类的成员必须声明protected

45 重写与重载的区别？

- 重写必须要有一个继承或者实现的关系，必然有个两个类或者是接口和实现类

- 重载的编写在本类中

- 重写是对父类的同一个方法的覆写，重载是对本类同一个方法的不同处理

45.5 重写的具体规则？

- 方法名称一致、形参列表一致、返回类型一致

- 权限修饰不得低于父类或者接口

- 抛出的异常自行处理或者继续抛出

46 super调用构造器有哪些要注意的？

- this() 调用本类构造器

- super() 向上访问父类构造器

47 使用关键字 this,super 重写和继承

// 圆类
public class Circle {
    // 半径
    private double radius;
    // 初始化1
    public Circle(){
        this.radius = 1;
    }
    // getter
    public double getRadius() {
        return radius;
    }
    // setter
    public void setRadius(double radius) {
        this.radius = radius;
    }
    // 求面积
    public double getRoundArea(){
        return Math.PI * Math.pow(radius,2);
    }
}

// 圆柱体类
class Cylinder extends Circle{
    // 柱长
    private double length;
    // 初始化1
    public Cylinder(){
        super();
        length = 1;
    }
    // GETTER
    public double getLength() {
        return length;
    }
    //SETTER
    public void setLength(double length) {
        this.length = length;
    }
    // 圆柱体积
    public double getVolume(){
        return getRoundArea() * length;
    }
    // 圆柱表面积
    public double getSurfaceArea(){
        // 柱面
        final double RECTANGLE_AREA = 2 * Math.PI * getRadius();
        // 上底 + 下底
        final double UP_AND_DOWN = 2 * getRoundArea();
        // 上底 下底 + 柱面
        return RECTANGLE_AREA + UP_AND_DOWN;
    }
}

48 如何向下转型？ 需要注意什么问题？ 如何解决？

- 使用强转符（）

- 可能出现 ClassCastException 类型不匹配异常

- 使用 instanceof 进行比较，判断对象是否属于此类的实例

49 == 和equals()有什么区别？

- == 是一个操作符，用来取变量的地址值进行比较

- equals是一个方法，在Object类的里面还是使用了==进行比较，但其他继承的类重写了equals，出了地址比较外，还有对实例内容的比较，

50 重写equals方法

class User{
    String name;
    int age;

    public boolean equals(Object object){
        if (this == object) return  true;
        else if (object instanceof User){
            User user = (User) object;
            if (this.age == user .age && this.name.equals(user .name))
            return true;
        }
        return false;
    }
}

51 写出8个基本类型的包装类

boolean　　Boolean

char　　　Chracter

byte　　　　Byte

short　　　　Short

int　　　　Integer

long　　　　Long

float　　Float

double　　Double

52 基本类型和包装类和String三者如何转换？

- 基本数据类型  和 包装类 自动装箱和拆箱

- 包装类 和 String

包装类数值 转 字符串 String.valueOf( 包装类对象 )

字符串 转 包装类数值 Integer.parseInt(字符串)

53 Static修饰的属性，相对于实例变量有哪些特别之处？

- 静态属性 优先 成员属性 加载

- 静态属性在内存空间是唯一的 多个实例访问静态变量都是同一个静态变量，存在在方法区的静态域

- 对象可以this.static修饰的属性进行访问

54 final 可以修饰哪些结构？ 分别表示哪些意思？

- 可修饰 类、方法、属性、局部变量

- 修饰局部变量表示，这个变量有且只能有唯一的一次赋值

- 修饰属性，同局部一样，但是可以使用显示声明、构造器注入、代码块注入

- 修饰方法， 表示此方法不能被重写，但是可以被重载

- 修饰类，表示类不能被继承，也表示默认隐式的表示方法不能被重写

55 实现饿汉式，单例模式

class Singleton{
    private Singleton(){}

    private static final Singleton INSTANCE = new Singleton();

    public static  Singleton getInstance(){
        return INSTANCE;
    }
}

56 实现懒汉式，单例模式

class Singleton{
    private Singleton(){}

    private static volatile Singleton instance;

    public static  Singleton getInstance(){
        if (instance == null) synchronized (Singleton.class) {
            if (instance == null) instance = new Singleton();
        }
        return instance;
    }
}

57 类的属性赋值有哪些？ 先后顺序？

隐式默认 - 显示初始化 - 代码块初始化 - 构造器注入 - setter注入/对象.属性注入

58 abstract能修饰的有哪些？修饰以后有什么特点？

- 修饰类 该类即为抽象类，不能实例化

- 修饰方法 该方法即为抽象方法 ，不能有方法体存在

59 接口能否继承接口？抽象类是否实现接口？抽象类是否继承非抽象类？

- 接口可以基础接口，还允许继承多接口

- 抽象类可以实现接口，可以不完全实现接口中的抽象方法

- 抽象类可以继承普通类

60 声明抽象类包含抽象方法 创建一个继承抽象类的匿名子类对象

public abstract class AbstractClass {
    public abstract void abstractMethod();
}

class Impl{
    public static void main(String[] args) {
        new AbstractClass(){
            @Override
            public void abstractMethod() {
                System.out.println("匿名实例实现");
            }
        }.abstractMethod();
    }
}

61 抽象类和接口有哪些共同点和区别？

- 都不能实例化，可以被继承

- 抽象类有构造器，但是接口没有

- 抽象类只能单继承，接口可以多接口继承

62 如何创建静态内部类和成员内部类？

public class ClassTest {
    public static void main(String[] args) {
        //  实例化静态内部类
        OuterClass.StaticInnerClass staticInnerClass = new OuterClass.StaticInnerClass();
        //  实例化成员内部类，必须要有外部类的实例才可以
        OuterClass outerClass = new OuterClass(); //先创建外部实例
        OuterClass.InnerClass innerClass = outerClass.new InnerClass(); //再通过外部实例调用内部初始化
    }
}