Java SE小结

目录

计算机硬件

冯诺依曼体系结构

Java中的内存管理

CPU的基本工作原理

语句角度

数据角度

类的职责

关键字

继承

多态

接口与抽象类

异常

---

• 计算机硬件

• 冯诺依曼体系结构

     1.运算器

     2.控制器              CPU：最初CPU只有一个核（core），核是处理器中实现指

                                        令读取和执行的部分。多核可提高CPU的处理能力

  

    3.存储器              内存：断电时丢失

                               外存：磁盘：永久的保存数据和程序

                                         光盘驱动器（CD和DVD）

                                         USB闪存驱动器        

    4.输入设备          （Java中体现为）终端设备、控制台设备、文件（硬盘）

    5.输出设备          （Java中体现为）终端、控制台、硬盘

冯诺依曼理论要点：数字计算机的数制采用二进制，程序存储

• Java中的内存管理

      1.比特（bit）和字节（byte）

                一个0或者一个1存储为一个比特，计算机中最小的存储单位

                计算机中最基本的存储单元是字节（byte），由8个bit构成

      2.一个程序和它的数据在被CPU执行前必须移到计算机的内存中

         （CPU操作的数据在内存中）

      3. 内存（硬件）——> OS ——> JVM ——> 栈区（由栈帧组成：每个栈帧对应一次方法调用）

      4. 局部变量就在该变量对应的方法的某次栈帧上

      5. 局部变量生命周期：

                                     开始于方法执行：JVM为本次方法分配栈帧

                                     结束于方法执行结束：JVM将方法执行中用到的栈帧回收

      6. 多次调用同一方法则有多个不同的栈帧

• CPU的基本工作原理

      1. 从内存中读取指令数据 

        （1）按照顺序，一条一条地读取 —— 顺序执行语句

        （2）按照指定地址去读取 —— 分支执行语句、循环执行语句

      2. 执行指令数据

• 语句角度

    1. Java中语句的出现位置

       （1）方法的内部

       （2）类的内部，作为属性定义时，赋值语句也可以出现

       （3）各种代码块（构造代码块、静态代码块）

       （4）出现在构造方法中

         注：  import java.util.Scanner 的这种导入包的操作不是语句

    2. 语句的执行触发

        （1）某个类被加载时

                 类的加载时机：

                        类被用到（用到了类的静态属性或调用静态方法；实例化一个对象；用到子类，触 

                       发用到父类）且类还没有被加载过时

                 类的加载执行顺序：

                        静态属性定义时的赋值语句、静态代码块中的语句（按书写顺序）

                        父类的所有加载语句执行完，才能执行子类的加载语句

       

        （2）某个类实例化对象时

                 和对象实例化有关的语句：

                        属性定义时的赋值语句；构造代码块中的语句；构造方法中的语句

                 执行顺序：

                        属性定义 和 构造代码块（按照书写顺序）

                        构造方法中的语句

                        子类的实例化，必须要求父类实例化语句全部完成后

                       

        （3）某个类中的方法被调用时

                 方法中的语句一定是被调用时才执行

                         静态方法，有类即可调用；

                         普通方法，必须先通过类实例化出对象，才能通过对象去调用

                         main方法，被JVM调用

• 数据角度

    1. 直接接触到的数据

       （1）变量

                基本类型：

                       byte int short long double float boolean char

                引用类型：

                       class类型；  接口类型；  数组类型

         (2)  字面量

               字符串常量：由""括起来的，比如“12345”、“hello”、“你好”。

               整形常量：程序中直接写的数字(注意没有小数点)，比如：100、1000

               浮点数常量：程序中直接写的小数，比如：3.14、0.49

               字符常量：由 单引号 括起来的当个字符，比如：‘A’、‘1’

               布尔常量：只有两种true和false

                空常量：null

    2. 无法直接接触到的数据

        （1）对象（属性）

        （2） 类（静态属性、类相关的方法、父类信息）

    3. 数据在内存的位置

        （1）JVM中，针对一个Java进程，内存分为栈区、堆区、方法区

        （2）对象逻辑上在堆区上

                方法的某次执行时需要的数据，以栈帧形式放在栈区

                类的数据，逻辑上放在方法去

                语句数据（指令、字节码数据、方法）放在方法区（无论静态方法还是普通方法）

                引用的位置不确定，需要其他条件

                变量的位置：

                       局部变量：存在于该方法执行时，创建的栈帧中（栈区）

                       对象的属性：存在于属性附着的对象上，即堆区

                       类的静态属性：存在于静态属性附着的类上，即方法区

                 数组的元素存在于元素附着的数组对象上，即堆区

• 类的职责

  1. 作为静态属性、静态方法的存在位置
  2. 作为构造对象的模板（属性、构造方法、方法）
  3. 为被继承的模板（属性、构造方法、方法）
  4. 抽象类和接口是其的特殊化

 

• 关键字

    1. static

        （1）静态导入

        （2）全部出现在类的内部，方法的外部

    2. final

           修饰变量、类、方法

    3. abstract

           修饰类、方法     

    4. this

          （1）在类的内部（构造方法中、在实例方法中）是一个引用，代表指向当前对象的引用

          （2）在构造方法中调用本类的其他构造方法，必须出现在最开始

 

• 继承

    1. 继承主要表示概念层上的 is-a 关系

    2. Java通过 extends 明确继承关系

        （1）一个子类只能继承一个父类

        （2）如果没有明确extends 默认继承自java.lang.Object

    3. 当父类的属性、方法权限是

              private：子类没有权限使用

              包访问权限：若子类、父类是同一个包下，就有权限

              protected：子类和父类同一个包下的类，有权限

              public：子类有权限

•     4. 子类对象的实例化之前，必须在子类的构造方法中，调用父类的构造方法

          （1）通过super关键字

          （2）当父类有无参构造方法时，super()可以省略

    5. 通过super 可以明确访问父类中的属性和方法（有访问权限的前提下）；没有名称歧义时，直接用this也可

• 多态

    1.任何对象都可以被其上层引用指向（向上转型），向上转型是自然的

    2. 能执行哪个方法，跟着引用类型走

    3. 某些情况，需要调用子类中的独有的某个方法必须向下转型

 

• 接口与抽象类

    1. 相同点：

          （1）不能被实例化

          （2）允许出现抽象方法

    2. 不同点：

           （1）接口只能出现抽象方法

           （2）普通类和抽象类之间的关系是继承关系，只能是单继承

                    普通类和接口之间的关系是实现关系，允许一个类实现多个接口

           （3）接口和接口之间也允许继承关系，允许多继承

           （4）抽象类中可以有属性、普通方法；接口中只能有抽象方法

           （5）类描述一类事物，接口描述一组能力

 

• 异常

   1. 异常中的关键字：

              try、catch、finally、throw、throws

              try + catch

              try + finally

              try + catch + finally

    2. 异常对象的构造方法和常见方法

        （1）无参构造方法

        （2）允许传入 String Message

        （3）通过一个异常，构造另一个异常

    3. 错误：因为设备（或者其他硬性环境导致，程序根本无法修复的问题。比如：CPU、硬盘烧了）

        非受查异常：因为程序的代码BUG导致的问题

        受查异常：经过重试、或者程序自动修复可以解决的问题