JavaSE 面向对象

前言

JavaSE oop概述和理解

正文

基本知识

成员变量和局部变量的区别

(1)在内存中的位置不同
    成员变量:在堆中
    局部变量:在栈中
(2)生命周期不同
    成员变量:随着对象的创建而存在,随着对象的消失而消失
    局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
(3)初始化值不同
    成员变量:有默认值
    局部变量:没有默认值,必须定义,赋值,然后才能使用

匿名对象

(1)没有名字的对象
(2)应用场景
    A:调用方法,仅仅只调用一次的时候。(用完即被垃圾回收器回收
    B:可以作为实际参数传递。

构造方法

如果我们给出了构造方法,系统将不再提供默认构造方法
如果这个时候,我们要使用无参构造方法,就必须自己给出。
推荐:永远手动自己给出无参构造方法。
把构造方法私有,外界就不能再创建对象了

static关键字

静态变量和成员变量的区别

A:所属不同
    静态变量:属于类,类变量
    成员变量:属于对象,对象变量,实例变量
B:内存位置不同
    静态变量:方法区的静态区
    成员变量:堆内存
C:生命周期不同
    静态变量:静态变量是随着类的加载而加载,随着类的消失而消失
    成员变量:成员变量是随着对象的创建而存在,随着对象的消失而消失
D:调用不同
    静态变量:可以通过对象名调用,也可以通过类名调用
    成员变量:只能通过对象名调用

代码块

(1)用{}括起来的代码。
(2)分类:
    A:局部代码块
        用于限定变量的生命周期,及早释放,提高内存利用率。
    B:构造代码块
        把多个构造方法中相同的代码可以放到这里,每个构造方法执行前,首先执行构造代码块。
    C:静态代码块
        对类的数据进行初始化,仅仅只执行一次。
(3)顺序问题?
    执行顺序优先级:静态块>main()>构造块>构造方法 
(4)有继承结构的执行顺序?
    父类静态对象和静态代码块 > 子类静态对象和静态代码块 > 
    父类非静态对象和非静态代码块 > 父类构造函数 > 
    子类非静态对象和非静态代码块 > 子类构造函数

final

(1)是最终的意思,可以修饰类,方法,变量。
(2)特点:  
    A:它修饰的类,不能被继承。
    B:它修饰的方法,不能被重写。
    C:它修饰的变量,是一个常量。
(3)面试相关:
    A:局部变量
        a:基本类型 值不能发生改变
        b:引用类型 地址值不能发生改变,但是对象的内容是可以改变的
    B:初始化时机
        a:只能初始化一次。
        b:常见的给值
            定义的时候。(推荐)
            构造方法完毕前。

抽象类

抽象类的成员特点

    A:成员变量:有变量,有常量
    B:构造方法:有构造方法
    C:成员方法:有抽象,有非抽象

面试一些问题

A:抽象类有构造方法,不能实例化,那么构造方法有什么用?
    用于子类访问父类数据的初始化
B:一个类如果没有抽象方法,却定义为了抽象类,有什么用?
    为了不让创建对象
C:abstract不能和哪些关键字共存
    a:final 冲突
    b:private 冲突
    c:static 无意义 //通过类来访问一个抽象的方法无意义

接口

(1)接口的特点:
    A:接口用关键字interface修饰
        interface 接口名 {}
    B:类实现接口用implements修饰
        class 类名 implements 接口名 {}
    C:接口不能实例化
    D:接口的实现类
        a:是一个抽象类。//没卵用啊
        b:是一个具体类,这个类必须重写接口中的所有抽象方法。
(2)接口的成员特点:
    A:成员变量
        只能是常量
        默认修饰符:public static final
    B:构造方法
        没有构造方法
    C:成员方法
        只能是抽象的
        默认修饰符:public abstract
(3)类与类,类与接口,接口与接口
    A:类与类
        继承关系,只能单继承,可以多层继承
    B:类与接口
        实现关系,可以单实现,也可以多实现。
        还可以在继承一个类的同时,实现多个接口
    C:接口与接口
        继承关系,可以单继承,也可以多继承

基本特征

封装

(1)隐藏实现细节,提供公共的访问方式
(2)好处:
    A:隐藏实现细节,提供公共的访问方式
    B:提高代码的复用性
    C:提高代码的安全性
(3)设计原则
    把不想让外界知道的实现细节给隐藏起来,提供公共的访问方式
(4)private是封装的一种体现。
    封装:类,方法,private修饰成员变量

继承

(1)继承的好处:
    A:提高了代码的复用性
    B:提高了代码的维护性
    C:让类与类产生了一个关系,是多态的前提
(2)继承的弊端:
    A:让类的耦合性增强。这样某个类的改变,就会影响其他和该类相关的类。
        原则:低耦合,高内聚。
        耦合:类与类的关系
        内聚:自己完成某件事情的能力
    B:打破了封装性    
(3)特点
    A:Java中类只支持单继承
    B:Java中可以多层(重)继承(继承体系)
(4)OverrideOverload
    Override 方法重写
    Overload 方法重载
    方法重载能改变返回值类型,重写不行

多态

(1)同一个对象在不同时刻体现出来的不同状态。
(2)多态的前提:
    A:有继承或者实现关系。
    B:有方法重写。
    C:有父类或者父接口引用指向子类对象。
    多态的分类:
        a:具体类多态
        b:抽象类多态
        c:接口多态
(3)多态中的成员访问特点
    A:成员变量
        编译看左边,运行看左边
    B:构造方法
        子类的构造都会默认访问父类构造
    C:成员方法
        编译看左边,运行看`右边`
    D:静态方法
        编译看左边,运行看左边
(4)多态的好处:
    A:提高代码的维护性(继承体现)
    B:提高代码的扩展性(多态体现)
(5)多态的弊端:
    父不能使用子的特有功能。
(6)多态中的转型
    A:向上转型
        从子到父 Fu f = new Zi();
    B:向下转型
        从父到子 Zi z = (Zi)f;

进阶知识

形式参数和返回值

(1)形式参数:
    类名:需要该类的对象
    抽象类名:需要该类的子类对象
    接口名:需要该接口的实现类对象
(2)返回值类型:
    类名:返回的是该类的对象
    抽象类名:返回的是该类的子类对象
    接口名:返回的是该接口的实现类的对象
(3)链式编程
    对象.方法1().方法2().......方法n();
    这种用法:其实在方法1()调用完毕后,应该一个对象;
              方法2()调用完毕后,应该返回一个对象。
              方法n()调用完毕后,可能是对象,也可以不是对象。

(1)其实就是文件夹
(2)作用:
    A:区分同名的类
    B:对类进行分类管理
        a:按照功能分
        b:按照模块分
(3)包的定义(掌握)
    package 包名;

    多级包用.分开。
(4)注意事项:(掌握)
    A:package语句必须在文件中的第一条有效语句
    B:在一个java文件中,只能有一个package
    C:如果没有package,默认就是无包名
(5)带包的编译和运行
    A:手动式
    B:自动式(掌握)
        javac -d . HelloWorld.java

修饰符

分类

权限修饰符:private,默认,protected,public
状态修饰符:static,final
抽象修饰符:abstract

权限修饰符

            本类     同一个包下   不同包下的子类 不同包下的无关类
private      Y
default      Y           Y
protected    Y           Y             Y
public       Y           Y             Y            Y    

常见的修饰

类:
    默认,public,final,abstract
    常用的:public

成员变量:
    private,默认,protected,public,static,final
    常用的:private

构造方法:
    private,默认,protected,public
    常用的:public

成员方法:
    private,默认,protected,public,static,final,abstract
    常用的:public

内部类

访问规则

A:可以直接访问外部类的成员,包括私有
B:外部类要想访问内部类成员,必须创建对象

位置

成员内部类

成员内部类不是静态的:
外部类名.内部类名 对象名 = new 外部类名.new 内部类名();
成员内部类是静态的:
外部类名.内部类名 对象名 = new 外部类名.内部类名();

  • 如果内部类想访问外部类的同名数据,可以通过外部类名限定this对象
    即类似 Outer.this.num的形式来调用
局部内部类

局部内部类访问局部变量必须加final修饰。

匿名内部类

A:是局部内部类的简化形式
B:前提
    存在一个类或者接口
C:格式:
    new 类名或者接口名() {
        重写方法;
    }
D:本质:
    其实是继承该类或者实现接口的子类匿名对象
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页