面向对象(基础)知识点强势总结!!!

文章目录

  • 一、知识点总结
    • (1)面向过程VS面向对象
    • (2)类、对象
    • (3)类的成员之一:属性(或成员变量)
    • (4)类的成员之二:方法
    • (5)再谈方法
      • 方法的重载
      • 可变个数形参的方法
      • 方法的参数传递机制
      • 递归方法
    • (6)对象数组
    • (7)package、import关键字的使用
    • (8)oop特征之一:封装性
    • (9)类的成员之三:构造器
    • (10)三个小知识
  • 二、企业真题
    • (1)类与对象
    • (2)Java内存结构
    • (3)权限修饰符(封装性)
    • (4)构造器
    • (5)属性及属性赋值顺序

一、知识点总结

(1)面向过程VS面向对象

  • 不管是面向过程、面向对象,都是程序设计的思路。
  • 面向过程:以函数为基本单位,适合解决简单问题。比如:开车
  • 面向对象:以类为基本单位,适合解决复杂问题。比如:造车

(2)类、对象

  • 类:抽象的、概念上的定义
  • 对象:具体的、类的一个一个的实例。
  1. 面向对象内容的三条主线:
  • Java类及类的成员:(重点)属性、方法、构造器;(熟悉)代码块、内部类
  • 面向对象的特征:封装、继承、多态、(抽象)
  • 其他关键字的使用:this、super、package、import、static、final、interface、abstract等
  1. 面向过程编程(POP) vs 面向对象编程(OOP)
    2.1 简单的语言描述二者的区别

面向过程:
- 以函数为组织单位。
- 是一种“执行者思维”,适合解决简单问题。扩展能力差、后期维护难度较大。

面向对象:
- 以为组织单位。每种事物都具备自己的属性行为/功能
- 是一种“设计者思维”,适合解决复杂问题。代码扩展性强、可维护性高。

2.2 二者关系:
我们千万不要把面向过程和面向对象对立起来。他们是相辅相成的。面向对象离不开面向过程!

面向对象编程的两个核心概念:类(Class)、对象(Object)
谈谈对这两个概念的理解?
类:具有相同特征的事物的抽象描述,是抽象的、概念上的定义。
对象:实际存在的该类事物的每个个体,是具体的,因而也称为实例(instance)

  1. 类的声明与使用
    4.1 体会:设计类,其实就是设计类的成员
class Person{

}

4.2 类的内部成员一、二:

成员之一:属性、成员变量、field(字段、域)

成员之二:(成员)方法、函数、method

4.3 类的实例化
等价描述:类的实例化 <=> 创建类的对象 <=> 创建类的实例
格式:类类型 对象名 = 通过new创建的对象实体
举例:

Phone p1 = new Phone();
Scanner scan = new Scanner(System.in);
String str = new String();
  1. 面向对象完成具体功能的操作的三步流程(非常重要
    步骤1:创建类,并设计类的内部成员(属性、方法)
    步骤2:创建类的对象。比如:Phone p1 = new Phone();
    步骤3:通过对象,调用其内部声明的属性或方法,完成相关的功能
  • 对象的内存解析

    • 创建类的一个对象;创建类的多个对象;方法的调用的内存解析
  • Java中内存结构的划分

    • Java中内存结构划分为:虚拟机栈、堆、方法区、程序计数器(PC寄存器)、本地方法栈

    • 虚拟机栈:以栈帧为基本单位,有入栈和出栈操作;每个栈帧入栈操作对应一个方法的执行;方法内的局部变量会存储在栈帧中(其实是将局部变量放在了局部变量表中,局部变量表是一个数组)。(局部变量放在栈里面

    • 面向对象(基础)知识点强势总结!!!_第1张图片

    • 堆空间:new出来的结构(数组、对象):①数组,数组的元素在堆中 ②对象的成员变量在堆中 (成员变量在堆里面

    • 方法区:加载的类的模板结构。比如:

    • 面向对象(基础)知识点强势总结!!!_第2张图片

    • 面向对象(基础)知识点强势总结!!!_第3张图片

【类的实例化剖析】

  1. 对象在内存中的分配涉及到的内存结构(理论)
  • 栈(stack): 方法内定义的变量,存储在栈中。
  • 堆(heap) : new 出来的结构(比如:数组实体、对象的实体)。包括对象中的属性
  • 方法区(method area) : 存放类的模板。比如:Person类的模板
  1. 类中对象的内存解析
    2.1 创建类的一个对象面向对象(基础)知识点强势总结!!!_第4张图片

2.2 创建类的多个对象

见《02-创建类的多个对象1.png》
面向对象(基础)知识点强势总结!!!_第5张图片

《02-创建类的多个对象2.png》
面向对象(基础)知识点强势总结!!!_第6张图片

强调1:创建了Person类的两个对象

Person p1 = new Person();
Person p2 = new Person();

说明:创建类的多个对象时,每个对象在堆空间中有一个对象实体。每个对象实体中保存着一份类的属性。

如果修改某一个对象的某属性值时,不会影响其他对象此属性的值。

p1.age = 10;

p2.age = 20;

p1.age = 30;

System.out.println(p2.age);//20

强调2:声明类的两个变量

Person p1 = new Person();
Person p3 = p1;

说明:此时的p1,p3 两个变量指向了堆空间中的同一个对象实体。(或p1,p3保存的地址值相同)

如果通过其中某一个对象变量修改对象的属性时,会影响另一个对象变量此属性的值。

p1.age = 10;

p3.age = 20;

System.out.println(p1.age);//20

2.3 对象调用方法的过程

面向对象(基础)知识点强势总结!!!_第7张图片

(3)类的成员之一:属性(或成员变量)

  • 属性VS局部变量
    • 声明的位置
    • 内存中存放的位置
    • 作用域
    • 权限修饰符
    • 初始化值
    • 生命周期

1.变量的分类:

  • 角度一:按照数据类型来分:基本数据类型(8种)、引用数据类型(数组、类、接口、枚举、注解、记录)
  • 角度二:按照变量在类中声明的位置的不同成员变量(或属性,写在类里面)、局部变量(方法内、方法形参、构造器内、构造器形参、代码块内等)
  1. 属性的几个称谓:成员变量属性field字段

  2. 区分成员变量 vs 局部变量
    3.1 相同点:

变量声明的格式相同:数据类型 变量名 = 变量值

变量都有其有效的作用域。出了作用域,就失效了。

变量必须先声明,后赋值,再使用。

3.2 不同点:

① 类中声明的位置的不同:

​ 属性:声明在类内,方法外的变量

局部变量:声明方法、构造器内部的变量

② 在内存中分配的位置不同(难):

属性:随着对象的创建,存储在堆空间中。

局部变量:存储在栈空间中

③ 生命周期:

属性:随着对象的创建而创建,随着对象的消亡而消亡。

局部变量:随着方法对应的栈帧入栈,局部变量会在栈中分配;随着方法对应的栈帧出栈,局部变量消亡。

④ 作用域:

属性:在整个类的内部都是有效的

局部变量:仅限于声明此局部变量所在的方法(或构造器、代码块)中

⑤ 是否可以有权限修饰符进行修饰:(难)

都有哪些权限修饰符:public、protected、缺省、private。(用于表明所修饰的结构可调用的范围的大小)

属性,是可以使用权限修饰符进行修饰的。 暂时还未讲封装性,所以大家先不用写任何权限符。
而局部变量,不能使用任何权限修饰符进行修饰的。

⑥ 是否有默认值:(重点)

属性:都有默认初始化值
意味着,如果没有给属性进行显式初始化赋值,则会有默认初始化值。

    局部变量:都没有默认初始化值。
    
    意味着,在使用局部变量之前,必须要显式的赋值,否则报错。

    注意:对于方法的形参而言,在调用方法时,给此形参赋值即可。

(4)类的成员之二:方法

  1. 使用方法的好处
    方法的理解:方法是类或对象行为特征的抽象,用来完成某个功能操作。
    方法的好处:实现代码重用,减少冗余,简化代码

  2. 使用举例

- Math.random()random()方法
- Math.sqrt(x)sqrt(x)方法
- System.out.println(x)println(x)方法
- new Scanner(System.in).nextInt()nextInt()方法
- Arrays类中的binarySearch()方法、sort()方法、equals()方法
  1. 声明举例
public void eat()
public void sleep(int hour)
public String interests(String hobby)
public int getAge()
  1. 方法声明的格式 (重要)
权限修饰符 [其它修饰符] 返回值类型 方法名(形参列表) [throws 异常类型]{ //方法头
    //方法体
}

注:[]中的内部不是必须的,以后再讲。

  1. 具体的方法声明的细节

5.1 权限修饰符

① Java规定了哪些权限修饰符呢? 有四种:private \ 缺省 \ protected \ public (放到封装性讲)

暂时大家声明方法时,可以先都写成public的。

5.2 返回值类型:描述当调用完此方法时,是否需要返回一个结果
分类:
> 无返回值类型:使用void表示即可。比如:System.out.println(x)println(x)方法、Arrayssort()
> 有具体的返回值类型:需要指明返回的数据的类型。可以是基本数据类型,也可以引用数据类型
> 需要在方法内部配合使用"return + 返回值类型的变量或常量"
比如:Math.random()new Scanner(System.in).nextInt()
[经验]我们在声明方法时,要不要提供返回值类型呢?
> 根据方法具体实现的功能来决定。换句话说,具体问题具体分析
> 根据题目要求

5.3 方法名:属于标识符。需要满足标识符的规定和规范。“见名知意”

5.4 形参列表:形参,属于局部变量,且可以声明多个。调用这个功能的时候是不是有不确定的内容,若是有,就用形参列表的方式表达
格式:(形参类型1 形参1,形参类型2 形参2,…)
分类:无形参列表 、 有形参列表
> 无形参列表:不能省略一对()。比如:Math.random()、new Scanner(System.in).nextInt()
> 有形参列表:根据方法调用时,需要的不确定的变量的类型和个数,确定形参的类型和个数。
比如:Arrays类中的binarySearch()方法、sort()方法、equals()方法

        [经验]我们在声明方法时,是否需要形参列表呢?
            > 根据方法具体实现的功能来决定。换句话说,具体问题具体分析
            > 根据题目要求

5.5 方法体: 当我们调用一个方法时,真正执行的代码。体现了此方法的功能。

  1. 注意点

Java里的方法不能独立存在,所有的方法必须定义在类里。

Java中的方法不调用,不执行。每调用一次,就执行一次。

方法内可以调用本类中的(其它)方法或属性

方法内不能定义方法。

7.关键字:return

7.1 return的作用

  • 作用1:结束一个方法
  • 作用2:结束一个方法的同时,可以返回数据给方法的调用者 (方法声明中如果有返回值类型,则方法内需要搭配return使用)

7.2 使用注意点:

​ return后面不能声明执行语句。

  1. 方法调用的内存解析:
  • 形参:方法在声明时,一对()内声明的一个或多个形式参数,简称为形参。
  • 实参:方法在被调用时,实际传递给形参的变量或常量,就称为实际参数,简称实参。

过程概述:略

(5)再谈方法

具体见博客:https://blog.csdn.net/m0_55746113/article/details/133964522

方法的重载

  1. 定义:在同一个类中,允许存在一个以上的同名方法,只要它们的参数列表不同即可
    满足这样特征的多个方法,彼此之间构成方法的重载。

  2. 总结为:“两同一不同”
    两同:同一个类、相同的方法名
    一不同:参数列表不同。① 参数个数不同 ② 参数类型不同

    注意:方法的重载与形参的名、权限修饰符、返回值类型都没有关系。

  3. 举例
    Arrays类中sort(xxx[] arr)、binarySearch(xxx[] arr,xxx)、equals(xxx[] ,yyy[])

  4. 如何判断两个方法是相同的呢?(换句话说,编译器是如何确定调用的某个具体的方法呢?)

如何判断两个方法是相同的呢? 方法名相同,且形参列表相同。(形参列表相同指的是参数个数和类型都相同,与形参名没关系)

要求:在一个类中,允许存在多个相同名字的方法,只要他们的形参列表不同即可。

编译器是如何确定调用的某个具体的方法呢?先通过方法名确定了一波重载的方法,进而通过不同的形参列表,确定具体的某一个方法。

  1. 在同一个类中不允许定义两个相同的方法。

可变个数形参的方法

  1. 使用场景
    在调用方法时,可能会出现方法形参的类型是确定的,但是参数的个数不确定。此时,我们就可以使用可变个数形参的方法

  2. 格式:(参数类型 ... 参数名)

  3. 说明:
    ① 可变个数形参的方法在调用时,针对于可变的形参赋的实参的个数可以为:0个、1个或多个
    ② 可变个数形参的方法与同一个类中,同名的多个方法之间可以构成重载
    ③ 特例:可变个数形参的方法与同一个类中方法名相同,且与可变个数形参的类型相同的数组参数不构成重载。
    ④ 可变个数的形参必须声明在形参列表的最后
    ⑤ 可变个数的形参最多在一个方法的形参列表中出现一次

方法的参数传递机制

  1. (复习)对于方法内声明的局部变量来说:如果出现赋值操作

    如果是基本数据类型的变量,则将此变量保存的数据值传递出去。
    如果是引用数据类型的变量,则将此变量保存的地址值传递出去。

  2. 方法的参数的传递机制:值传递机制
    面向对象(基础)知识点强势总结!!!_第8张图片

面向对象(基础)知识点强势总结!!!_第9张图片

2.1 概念(复习)

形参:在定义方法时,方法名后面括号()中声明的变量称为形式参数,简称形参。

实参:在调用方法时,方法名后面括号()中的使用的值/变量/表达式称为实际参数,简称实参。

2.2 规则:实参给形参赋值的过程
> 如果形参是基本数据类型的变量,则将实参保存的数据值赋给形参。
> 如果形参是引用数据类型的变量,则将实参保存的地址值赋给形参。

  1. 面试题:Java中的参数传递机制是什么?值传递。(不是引用传递)

递归方法

  1. 何为递归方法?方法自己调用自己的现象就称为递归。

  2. 递归方法分类:直接递归、间接递归

  3. 使用说明:

  • 递归方法包含了一种隐式的循环
  • 递归方法会重复执行某段代码,但这种重复执行无须循环控制。
  • 递归一定要向已知方向递归,否则这种递归就变成了无穷递归,停不下来,类似于死循环。最终发生栈内存溢出

注意:

  1. 递归调用会占用大量的系统堆栈,内存耗用多,在递归调用层次多时速度要比循环慢的多
    所以在使用递归时要慎重。
  2. 在要求高性能的情况下尽量避免使用递归,递归调用既花时间又耗内存。考虑使用循环迭代

相较于循环结构,递归方法效率稍低,内存占用偏高。

(6)对象数组

  1. 何为对象数组?如何理解?
    数组的元素可以是基本数据类型,也可以是引用数据类型。当元素是引用类型中的类时,我们称为对象数组。

  2. 举例

String[],Person[],Student[],Customer[]
  1. 案例
    1)定义类Student,包含三个属性:学号number(int),年级state(int),成绩score(int)。
    2)创建20个学生对象,学号为1到20,年级和成绩都由随机数确定。
    问题一:打印出3年级(state值为3)的学生信息。
    问题二:使用冒泡排序按学生成绩排序,并遍历所有学生信息
    提示:
  1. 生成随机数:Math.random(),返回值类型double;
  2. 四舍五入取整:Math.round(double d),返回值类型long。
    年级[1,6] : (int)(Math.random() * 6 + 1)
    分数[0,100] : (int)(Math.random() * 101)

代码
【Student.java】

public class Student {

    //属性
    int number;//学号
    int state;//年级
    int score;//成绩

    //声明一个方法,显示学生的属性信息
    public String show(){
        return "number : " + number + ",state : " +
        state + ", score : " + score;
    }
}

【StudentTest.java】

public class StudentTest {
    public static void main(String[] args) {

        //创建Student[]
        Student[] students = new Student[20]; //String[] strs = new String[20];

        //使用循环,给数组的元素赋值
        for (int i = 0; i < students.length; i++) {
            students[i] = new Student();
            //给每一个学生对象的number、state、score属性赋值
            students[i].number = i + 1;
            students[i].state = (int)(Math.random() * 6 + 1);
            students[i].score = (int)(Math.random() * 101);
        }

        //需求1:打印出3年级(state值为3)的学生信息
        for (int i = 0; i < students.length; i++) {
            if(3 == students[i].state){
                Student stu = students[i];
                //                System.out.println("number : " + stu.number + ",state : " +
                //                        stu.state + ", score : " + stu.score);

                System.out.println(stu.show());
            }
        }


        //需求2:使用冒泡排序按学生成绩排序,并遍历所有学生信息
        //排序前遍历
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i].show());
        }

        System.out.println("********************");
        for (int i = 0; i < students.length - 1; i++) {
            for (int j = 0; j < students.length - 1 - i; j++) {
                if(students[j].score > students[j + 1].score){
                    //错误的,不满足实际需求!
                    //                    int temp = students[j].score;
                    //                    students[j].score = students[j + 1].score;
                    //                    students[j + 1].score = temp;

                    //正确的
                    Student temp = students[j];
                    students[j] = students[j + 1];
                    students[j + 1] = temp;
                }
            }
        }

        //排序后遍历
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i].show());
        }

    }
}
  1. 内存解析
    面向对象(基础)知识点强势总结!!!_第10张图片

  2. 拓展:提供封装Student相关操作的工具类

(7)package、import关键字的使用

具体内容博客链接:https://blog.csdn.net/m0_55746113/article/details/133970476

  • package:指明声明的类所属的包
  • import:当前类中,如果使用其他包下的类(除java.lang包),原则上就需要导入。

一、package关键字的使用

  1. 说明
  • package:包
  • package用于指明该文件中定义的类、接口等结构所在的包
  • 一个源文件只能有一个声明包的package语句
  • package语句作为Java源文件的第一条语句出现。若缺省该语句,则指定为无名包。
  • 包名,属于标识符,满足标识符命名的规则和规范(全部小写)、见名知意
    • 包通常使用所在公司域名的倒置:com.atguigu.xxx。
    • 大家取包名时不要使用"java.xx"包
  • 包对应于文件系统的目录,package语句中用 “.” 来指明包(目录)的层次,每.一次就表示一层文件目录。
  • 同一个包下可以声明多个结构(类、接口),但是不能定义同名的结构(类、接口)。不同的包下可以定义同名的结构(类、接口)
  1. 包的作用
  • 包可以包含类和子包,划分项目层次,便于管理
  • 帮助管理大型软件系统:将功能相近的类划分到同一个包中。比如:MVC的设计模式
  • 解决类命名冲突的问题
  • 控制访问权限
  1. JDK中主要的包
    java.lang----包含一些Java语言的核心类,如String、Math、Integer、 System和Thread,提供常用功能
    java.net----包含执行与网络相关的操作的类和接口。
    java.io ----包含能提供多种输入/输出功能的类。
    java.util----包含一些实用工具类,如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
    java.text----包含了一些java格式化相关的类
    java.sql----包含了java进行JDBC数据库编程的相关类/接口
    java.awt----包含了构成抽象窗口工具集(abstract window toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)。

二、import关键字的使用

  • import : 导入
  • import语句来显式引入指定包下所需要的类。相当于import语句告诉编译器到哪里去寻找这个类
  • import语句,声明在包的声明和类的声明之间。
  • 如果需要导入多个类或接口,那么就并列显式多个import语句即可
  • 如果使用a.*导入结构,表示可以导入a包下的所有的结构。举例:可以使用java.util.*的方式,一次性导入util包下所有的类或接口。
  • 如果导入的类或接口是java.lang包下的,或者是当前包下的,则可以省略此import语句。
  • 如果已经导入java.a包下的类,那么如果需要使用a包的子包下的类的话,仍然需要导入。
  • 如果在代码中使用不同包下的同名的类,那么就需要使用类的全类名的方式指明调用的是哪个类。
  • (了解)import static组合的使用:调用指定类或接口下的静态的属性或方法

(8)oop特征之一:封装性

具体内容博客链接:https://blog.csdn.net/m0_55746113/article/details/133980641

  1. 为什么需要封装性?
    理论上:
    -高内聚:类的内部数据操作细节自己完成,不允许外部干涉;
    -低耦合:仅暴露少量的方法给外部使用,尽量方便外部调用。

通俗的说:把该隐藏的隐藏起来,该暴露的暴露出来。这就是封装性的设计思想。

  1. 如何实现数据封装?
    2.1 权限修饰符
    Java规定了4种权限修饰,分别是:private、缺省、protected、public

2.2 作用

我们可以使用4种权限修饰来修饰类及类的内部成员。当这些成员被调用时,体现可见性的大小。

2.3 实际案例:

在题目中,我们给Animal的对象的legs属性赋值。在实际的常识中,我们知道legs不能赋值为负数的。但是如果

直接调用属性legs,是不能加入判断逻辑的。那怎么办呢?

将legs属性私有化(private),禁止在Animal类的外部直接调用此属性

提供给legs属性赋值的setLegs()方法,在此方法中加入legs赋值的判断逻辑if(legs >= 0 && legs % 2 ==0)

将此方法暴露出去,使得在Animal类的外部调用此方法,对legs属性赋值。

提供给legs属性获取的getLegs()方法,此方法对外暴露。使得在Animal类的外部还可以调用此属性的值。

2.4 4种权限具体使用
面向对象(基础)知识点强势总结!!!_第11张图片

类:只能使用public、缺省修饰

类的内部成员:可以使用4种权限修饰进行修饰。

2.5 开发中4种权限使用频率的情况:

比较高:public、private

比较低:缺省、protected

  1. 封装性的体现

场景1:私有化(private)类的属性,提供公共(public)的get和set方法,对此属性进行获取或修改

场景2:将类中不需要对外暴露的方法,设置为private.

场景3:单例模式中构造器private的了,避免在类的外部创建实例。(放到static关键字后讲)


问:什么是封装性?

(错误)答:在创建一个类的时候,把类的属性私有化,提供公共的set、get方法去访问和设置。(不能以偏概全)

(正确)答:

① Java规定了4种权限修饰,分别是:private、缺省、protected、public,我们可以使用4种权限修饰来修饰类及类的内部成员。当这些成员被调用时,体现可见性的大小。

②举例

场景1:私有化(private)类的属性,提供公共(public)的get和set方法,对此属性进行获取或修改

场景2:将类中不需要对外暴露的方法,设置为private.

场景3:单例模式中构造器private的了,避免在类的外部创建实例。(放到static关键字后讲)

③上理论

-高内聚:类的内部数据操作细节自己完成,不允许外部干涉;(Java程序通常以类的形态呈现,相关功能封装到方法中)

-低耦合:仅暴露少量的方法给外部使用,尽量方便外部调用。(给相关的类、方法设置权限,把该隐藏的隐藏起来,该暴露的暴露出去)

(9)类的成员之三:构造器

具体内容博客链接:https://blog.csdn.net/m0_55746113/article/details/134002260

  1. 构造器的理解
    constructor :n. 建设者、建造者
    construct:v. 建设、建造、创造
    construction: n. 建设、建造 CCB

  2. 构造器的作用
    作用1:搭配new关键字,创建类的对象
    作用2:在创建对象的同时,可以给对象的相关属性赋值(初始化对象的成员变量)

  3. 构造器的使用说明

构造器声明的格式:权限修饰符 类名(形参列表){}

创建类以后,在没有显示提供任何构造器的情况下,系统会默认提供一个空参的构造器,且构造器的权限
与类声明的权限相同。

一旦类中显示声明了构造器,则系统不再提供默认的空参的构造器。

一个类中可以声明多个构造器,彼此之间构成重载。

(10)三个小知识

具体内容博客链接:https://blog.csdn.net/m0_55746113/article/details/134016731

一、类中属性(当前仅考虑实例变量)赋值过程:

  1. 在类的属性中,可以有哪些位置给属性赋值?
    ① 默认初始化;
    ② 显式初始化;
    ③ 构造器中初始化;

④ 通过"对象.方法"的方式赋值;

⑤ 通过"对象.属性"的方式赋值;

  1. 这些位置执行的先后顺序是怎样?
    ① - ② - ③ - ④/⑤

  2. 以上操作在对象创建过程中可以执行的次数如何?

只能执行一次:①、②、③

可以多次执行:④、⑤

二、JavaBean的理解

所谓JavaBean,是指符合如下标准的Java类:

  • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性,且有对应的get、set方法

三、读懂UML类图
面向对象(基础)知识点强势总结!!!_第12张图片

二、企业真题

(1)类与对象

1.面向对象、面向过程的理解?

答:

  • 不管是面向过程、面向对象,都是程序设计的思路。
  • 面向过程:以函数为基本单位,适合解决简单问题。比如:开车
  • 面向对象:以类为基本单位,适合解决复杂问题。比如:造车

2.Java的引用类型有哪几种?

答:类、数组、接口;枚举、注解、记录
面向对象(基础)知识点强势总结!!!_第13张图片

3.类和对象的区别

答:

  • 类:抽象的、概念上的定义
  • 对象:具体的、类的一个一个的实例。

4.面向对象,你解释一下,项目中哪些地方用到面向对象?

答:“万事万物皆对象”

(2)Java内存结构

1.Java虚拟机中内存划分为哪些区域,详细介绍一下

答:略。

2.对象存在Java内存的哪块区域里面?

答:堆空间。

(3)权限修饰符(封装性)

1.private、缺省、protected、public的表格化作用区域

答:略。

2.main方法的public能不能换成private?为什么?

答:能。但是改以后就不能作为程序的入口了。就只是一个普通的方法。

(4)构造器

1.构造方法和普通方法有什么区别?

答:构造方法–构造器

普通方法–method方法

从编写代码的角度:没有共同点,声明格式、作用都不同。

字节码文件角度:构造器会以()方法的形态去呈现,用于初始化对象。方法名就叫init,因为构造器的名字与类名一致。

2.构造器Constructor是否可被overload(重载)?

答:可以。(构造器不能重启,能重载)

3.无参构造器和有参构造器的作用和应用

答:略。

(5)属性及属性赋值顺序

1.成员变量与局部变量的区别

答:6个点。

  • 属性VS局部变量
    • 声明的位置
    • 内存中存放的位置
    • 作用域
    • 权限修饰符
    • 初始化值
    • 生命周期

2.变量赋值和构造方法加载的优先级问题

答:变量显示赋值先于构造器中的赋值。

你可能感兴趣的:(Java基础,Java,面向对象(基础),知识总结)