面向对象的几个问题

Posted 2020-09-26

1.面向对象思想的特点
     (1)是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)
     (2)可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
     (3)角色发生了转换，将我们从执行者变成了指挥者
     (4)就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）
2.面向对象的特征
     (1)封装:是隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
     (2)继承:把多个类中相同的属性提取出来定义到一个类中。
     (3)多态:同一个对象不同时刻体现出来的不同状态。
3.类与对象的关系
     (1)是一组相关的属性和行为的集合（所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）
     (2)对象是该类事物的具体体现（例如每个同学都具备自己特有的属性和行为）
     (3)类是抽象(抽取出同类事物中相同的、相似的部分就叫抽象)的,对象是具体的或者是类是一般的，对象是特殊的
     (4)类中可以包含成员变量、类变量、成员方法、类方法、构造函数、构造代码块、静态代码块等
4.成员变量和局部变量的区别？
     (1)在类中的位置不同
         a.成员变量：在类中方法外
         b.局部变量：在方法定义中或者方法声明上
     (2)在内存中的位置不同
         a.成员变量：在堆内存(成员变量属于对象,对象进堆内存)
         b.局部变量：在栈内存(局部变量属于方法,方法进栈内存)
     (3)生命周期不同
         a.成员变量：随着对象的创建而存在，随着对象的消失而消失
         b.局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
     (4)初始化值不同
         a.成员变量：有默认初始化值
         b.局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
5.private关键字的特点
     (1)封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式，private是实现封装的一种形式
     (2)private是一个权限修饰符，可以修饰成员变量和成员方法
     (3)被private修饰的成员，只能在本类中访问
     (4)当成员变量被private关键字修饰后，需要提供对应的get和set方法供外部访问
6.谈谈你对this的理解？
     (1)this只能代表本类对象
     (2)this代表所属函数(方法)的所属对象
     (3)谁来调用我，我就代表谁
     (4)this可用于区分成员变量和局部变量同名的情况
        

1.构造方法的特点？
     (1)构造方法主要作用是给对对象的属性进行初始化
     (2)方法名与类名完全一致，没有返回值类型，连void都没有
     (3)构造方法也是方法，只是比较特殊，是在创建对象后马上调用，后期不能单独调用，既然是方法，就可以重载
         a.方法名相同
         b.参数列表不同(数量不同，顺序不同，类型不同)
         c.与返回值类型无关
     (4)如果自定义类中没有提供构造方法，系统将自动提供一个无参构造方法，如果我们给出了构造方法，系统将不再提供默认的无参构方法，要想再使用空参构造，必须显示给出
2.java中创建一个对象的过程？
     (1)将类的字节码文件加载进内存
     (2)声明一个该类类型引用
     (3)在堆内存创建对象s
     (4)给对象中属性默认初始化值
     (5)属性进行显示初始化
     (6)构造方法进栈,对对象中的属性赋值, 构造方法弹栈
     (7)将对象的地址值赋值给s
3.谈谈你对static关键字的理解？
     (1)被static关键字修饰的成员，属于该类中所有对象的共享内容可以直接用类名调用，也可以用对象调用，但是建议用类名调用
     (2)随着类的加载而加载,优先于对象存在：随着字节码文件的加载而加载的，那时候还没有对象呢
     (3)静态修饰的内容一般我们称其为：与类相关的，类成员（静态变量：类变量，静态方法：类方法）
     (4)在静态方法中是没有this关键字的(因为this指的是一个具体的对象,而静态在加载到内存时还没有具体的对象)
     (5)静态方法只能访问静态的成员变量和静态的成员方法,非静态的成员方法既可以方法静态的成员方法和成员变量，又能访问非静态的成员方法和成员变量.(静态不能访问非静态)
4.静态变量和成员变量的区别？
     (1)所属不同
         a.静态变量属于类，所以也称为为类变量
         b.成员变量属于对象，所以也称为实例变量(对象变量)
     (2)内存中位置不同
         a.静态变量存储于方法区的静态区
         b.成员变量存储于堆内存
     (3)内存出现时间不同
         a.静态变量随着类的加载而加载，随着类的消失而消失
         b.成员变量随着对象的创建而存在，随着对象的消失而消失
     (4)调用不同
         a.静态变量可以通过类名调用，也可以通过对象调用
         b.成员变量只能通过对 象名调用
    
2.谈谈你对继承的理解？
     (1)继承与类之间产生关系,子父类关系
     (2)继承提高了代码的复用性和维护性，单同时增加了类与类之间的耦合性
     (3)java只支持单继承，不支持多继承,但是Java支持多层继承
     (4)继承中的注意事项：
         a.子类只能继承父类所有非私有的成员(成员方法和成员变量)
         b.子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
         c.不要为了部分功能而去继承
     (5)在创建对象时，子类中所有的构造方法默认都会访问父类中空参数的构造方法
         a.因为子类会继承父类中的数据，可能还会使用父类的数据,所以，子类初始化之前，一定要先完成父类数据的初始化。           
         b.其实:每一个构造方法的第一条语句默认都是：super() Object类最顶层的父类。
     (6)父类没有无参构造方法,子类怎么办?
         a.super解决:用super(....)显式调用父类的有参构造,如:super(name,age);->super("zs",30);
         b.this解决:通过this调用本类的有参构造,然后在本类的有参构造里,又调用了父类的有参构造,相当于间接调用父类的有参构造.
         c.super(…)或者this(….)必须出现在构造方法的第一条语句上,只能出现其一
     (7)继承中成员方法关系?
         a.不同名的方法:直接调用就可以
         b.同名的方法:称为方法的重写,用子类对象直接调用的是子类已经重写的方法   
         c.要想调用父类的方法,可以在子类重写的方法中添加super();
        
3.谈谈你对this和super关键字的理解？
     (1)this:代表当前对象的引用,谁来调用我,我就代表谁
     (2)super:代表当前对象父类的引用
     (3)this和super的使用区别
         a.调用成员变量
             * this.成员变量 调用本类的成员变量,也可以调用父类的成员变量
             * super.成员变量 调用父类的成员变量
         b.调用构造方法
             * this(...)    调用本类的构造方法
             * super(...)    调用父类的构造方法
         c.调用成员方法
             * this.成员方法 调用本类的成员方法,也可以调用父类的方法
             * super.成员方法 调用父类的成员方法
4.什么是方法的重载和重写？
     (1)重载：在同一个类中，方法名相同、参数列表不同(数量不同、类型不同、顺序不同)、与返回值类型无关的多个方法构成重载
     (2)重写：在继承中，子父类出现了一模一样的方法(返回值类型可以是子父类)
         当子类需要父类的功能而功能主体子类有特有内容时，可以重写父类中的方法。这样，即沿袭了父类的功能，又定义了子类有的内容
     (3)重写的注意事项
         a.父类中私有法不能被重写,因为父类私有方法子类根本就无法继承,既然子类无法继承,就谈不上重写
         b.子类重写父方法时，访问权限不能更低,最好就一致
         c.父类静态方法，子类也必须通过静态方法进行重写
             * 其实这个算不上方法重写，但是现实确实如此.至于为什么算不上方法重写(静态只能覆盖静态)
         d.子类重写父类方法的时候，最好声明一模一样。
5.final关键字的特点？
     (1)修饰类，类不能被继承
     (2)修饰变量，变量就变成了常量，只能被赋值一次
     (3)修饰方法，方法不能被重写(有时所有方法都很重要，都不需要被重写，需要将类定义成final的)
     (4)final修饰局部变量：基本类型，是值不能被改变，引用类型，是地址值不能被改变,对象中的属性可以改变
     (5)final修饰变量的初始化时机？
         a.未被static关键字修饰
             * 可以显示初始化
             * 可以在构造方法中初始化
         b.被static修饰
             * 可以显示初始化
             * 可以在静态代码块中初始化
             * 不能在构造方法中初始化
                
1.谈谈你对多态的理解？
     (1)多态就是事物存在的多种形态
     (2)多态的前提
         a.要有继承关系。
         b.要有方法重写。
         c.要有父类引用指向子类对象。
     (3)多态中的成员访问特点
         a.成员方法：编译时看父类(左边)，运行时看子类(右边)
         b.成员变量：编译时看父类(左边)，运行时看父类（左边)
         c.静态方法：编译看父类(左边)，运行看父类(左边)。
             (静态和类相关，算不上重写，所以，访问还是左边的)
             只有非静态的成员方法,编译看左边,运行看右边
     (4)多态的好处和弊端
         a.好处
             * 提高了代码的维护性(继承保证)
             * 提高了代码的扩展性(由多态保证)，可以当作形式参数,可以接收任意子类对象
         b.弊端
             * 不能使用子类的特有属性和行为
2.谈谈你对抽象类的理解？
     (1)抽象类的概述？
         a.在某些情况下,父类只知道子类包含怎样的方法,无法准确知道这些子类如何实现该方法
         b.多个具有相同特征的类中抽取一个抽象类,以这个抽象类为子类的模板,从而避免子类设计的随意化
         c.限制子类必须有哪些方法,不关注实现细节.
     (2)抽象类特点
         a.抽象类和抽象方法必须用abstract关键字修饰
             * abstract class 类名 {}
             * public abstract void 方法名();//当不知道该方法具体是怎么实现的                       
         b.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
         c.抽象类不能实例化那么，抽象类如何实例化呢?
             * 按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
         d.抽象类的子类
             * 要么是抽象类
             * 要么重写抽象类中的所有抽象方法
     (3)抽象类的成员特点
         a.成员变量：既可以是变量，也可以是常量。abstract是否可以修饰成员变量?不能修饰成员变量
         b.构造方法：必须有。
             * 用于子类访问父类数据的初始化。
         c.成员方法：既可以是抽象的，也可以是非抽象的。
             * 抽象方法 强制要求子类做的事情。
             * 非抽象方法 子类继承的事情，提高代码复用性。
3.abstract关键字不能与哪些关键字共同使用
     (1)abstract和static
         被abstract修饰的方法没有方法体
         被static修饰的可以用类名.调用,但是类名.调用抽象方法是没有意义的
     (2)abstract和final
         被abstract修饰的方法强制子类重写
         被final修饰的不让子类重写,所以他俩是矛盾
     (3)abstract和private
         被abstract修饰的是为了让子类看到并强制重写
         被private修饰不让子类访问,所以他俩是矛盾的
4.谈谈你对接口的理解？
     (1)接口概述
         回顾猫狗案例，它们仅仅提供一些基本功能。
            比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的，是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。
     (2)接口特点
         a.接口用关键字interface表示   
             * interface 接口名 {}
         b.类实现接口用implements表示
             * class 类名 implements 接口名 {}
         c.接口不能实例化
             * 那么，接口如何实例化呢?
             * 按照多态的方式来实例化。
         d.接口的子类
             * a:可以是抽象类。但是意义不大。
             * b:可以是具体类。要重写接口中的所有抽象方法。
     (3)接口成员特点
         a.成员变量只能是常量，并且是静态的并公共的。
             * 默认修饰符：public static final
             * 建议：自己手动给出。
         b.构造方法：接口没有构造方法。
         c.成员方法：只能是抽象方法。
             * 默认修饰符：public abstract
             * 建议：自己手动给出。
5.简述类与类,类与接口,接口与接口的关系？
     (1)类与类：
         a.继承关系,只能单继承,可以多层继承。
     (2)类与接口：
         a.实现关系,可以单实现,也可以多实现。
         b.并且还可以在继承一个类的同时实现多个接口。
     (3)接口与接口：
         a.继承关系,可以单继承,也可以多继承。
6.谈谈你对抽象类和接口的理解？
     (1)成员区别
         a.抽象类：
             * 成员变量：可以变量，也可以常量
             * 构造方法：有
             * 成员方法：可以抽象，也可以非抽象
         b.接口：
             * 成员变量：只可以常量
             * 成员方法：只可以抽象
     (2)关系区别
         a.类与类
             * 继承，单继承
         b.类与接口
             * 实现，单实现，多实现
         c.接口与接口
             * 继承，单继承，多继承
     (3)设计理念区别(面试时最好最初例子来)
         a.抽象类 被继承体现的是：”is a”（属于）的关系。抽象类中定义的是该继承体系的共性功能。
         b.接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
             * 对事物本质的抽象用抽象类，对事物功能的扩展用接口
                
1.java中哪几种权限修饰符，其对应的访问权限是什么？
                       本类     同一个包下(子类和无关类)    不同包下(子类)    不同包下(无关类)
         private         Y       
         默认            Y                 Y
         protected           Y                 Y                    Y
         public            Y                 Y                    Y                 Y