【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;
    }
}
View Code

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(); //再通过外部实例调用内部初始化
    }
}

猜你喜欢

转载自www.cnblogs.com/mindzone/p/12732194.html
今日推荐