college java复习

college java复习

一、java入门

• 编写计算机程序的语言，通常 分为三类：机器语言，汇编语言，高级语言

• 源程序与目标程序：

  • 源程序：用高级语言编写的程序称为源程序
  • 目标程序：由于计算机不识别源程序，所以使用一种称为编译器 （compiler）的程序将源程序翻译成低级语言的程序， 这种低级语言程序称为目标程序

• java 具有语法简单，面向对象，稳定，与平台无关，多线程，动态等特点

• java能在所有的计算机上兼容的原因是：java可以在计算机的操作系统上再提供一个java运行环境（JRE），该运行环境由java虚拟机（JVM）,类库以及一些核心文件组成。也就是说只要平台提供了java运行环境（JRE），java编写的软件就能在其上运行。

• java虚拟机（JVM）

  • 无论哪种Java开发平台都需要具有Java虚拟机 （Java Virtual Machine）

  • Java虚拟机的核心是所谓的字节码指令

    • 字节码是可以被java虚拟机直接识别，执行的一种由 0,1组成的序列代码。

    • 字节码不是机器指令，因为他不和特定的平台相关，不能被任何平台直接识别，执行

    • java针对不同平台提供的java虚拟机的字节码指令都是相同的，因此能够实现平台无关性，例如所有的虚拟机都将11110000识别，执行为加法操作。

  • 与c/c++不同，java语言提供的编译器不针对特定的操作系统和cpu芯片进行编译，而是针对虚拟机把java源程序编译程被称为“字节码”（能够被虚拟机识别的）的“中间代码”。(其他语言的编译器是针对性的将源程序编译成机器语言而java语言的编译器是将其编译成字节码)

  • 虚拟机负责将字节码文件（包括程序使用的类库中的字节码）加载到内存，然后采用解释方式(翻译一句执行一句)来执行字节码文件。

    

• java程序的开发步骤

  • 编写源文件：扩展名必须是 .java。
  • 编译Java源程序：用Java编译器（javac.exe）编译源文件， 得到字节码文件（* . class）。
  • 运行Java程序：使用Java解释器（java.exe）来解释执行 字节码文件。

• 应用程序接口（API）：也称为库，包含了为开发java程序而预定义的类和接口，包含在jdk。

• JDK和JRE

  • JRE：Java Runtime Environment （Java运行时环境）

    包含了运行Java程序的所需要的所 有组件，如JVM、动态库等。

  • JDK：Java Development Kit （Java开发工具包）

    • 包含 JRE， 开发、调试所需要的各种工具、类库等

    • JDK 1.8包含有数千个类（classes），数万个方法 （methods），涵盖了 网络 ， 文件IO ， 桌面（Swing/AWT）系统 ， 安全 ， 分布式操作 ， 数据库访问等

    • JDK的主要内容如下：

      • 开发工具

        位于bin子目录中。指工具和实用程序，可帮助开发，执行，调试以java编程语言编写的程序，例如编译器javac.exe和解释器java.exe都位于该目录中。
        

      • java运行环境

        位于jre子目录中。java运行环境包括java虚拟机，类库，以及其他支持执行以java编程语言编写的程序的文件。

      • 附加库

        位于lib子目录。开发工具所需的其他类库和支持文件。

      • C头文件

        位于include的子目录中。支持使用java本机界面，jvm工具界面以及java平台的其他功能进行本机代码编程的头文件

      • 源代码

        位于JDK安装目录之根目录中的sre.zip文件是Java核心API的所有类的Java编程语言
        源文件(即java.* 、 javax.* 和某些org. * 包的源文件,但不包括com.un*包的源文件)。

  • JDK,JRE,JVM 的关系

    

二、基本程序设计

• Java的数据类型分为两大类：基本数据类型和引用数据类型

  基本数据中保存数据值，而引用类型数据中保存地址

  

• 转型

  转型范围排序：double>float>long>int

  • 隐式转型：小范围可给大范围赋值

    		int a=10;
    		double b=a;
    		System.out.println(b);  //结果10.0
    

  • 显式转型：大范围转成小范围 需要强制转型

    		double b=10.0;
    		int a=(int)b;
    		System.out.println(a);  //结果10
    

• 标识符命名规则

  • 标识符是一个由字符、数字、下划线（ _ ）或美元符号（$）构成 的字符串
  • 标识符必须以字符、下划线（_）或美元符号（$）开头，不能用 数字开头
  • 标识符不能是Java保留字 和 true、false、null等字面常量
  • 标识符可以有任意的长度，但实际命名不宜过长

• 实例数值运算

  

  两数取余时，只有当被除数是负数时，余数才是负的 （其它情况均为正）

• 幂运算

  语法格式：Math.pow(a , b),表示a的b次方 (double类型)

• ASCII码

  

• java 运算符优先级

  

• 数学函数

  • 三角函数

    

    

  • 取整函数

    

  • 随机值

    • Math.random():

      • 获取区间[a, b) 内的一个随机整数：

      (int)( a + Math.random( ) *(b - a) )
      

      • 获取区间 a ～ b 之间的一个随机整数：

      (int)( a + Math.random( ) *(b – a + 1) )
      

    • random.next…():

      • 获取区间[a, b) 内的一个随机整数：

      a+ran.nextInt(b-a)
      

      • 获取区间 a ～ b 之间的一个随机整数：

      a+ran.nextInt(b-a+1)
      

• 字符类型与数值类型的转换

  • 字符类型可以转换成任意的数值类型

    • 隐式转换（当转换结果适用于目标变量）

      byte x = 'a'; // 'a'的Unicode码是97，在byte和int范围内
      int y = 'a'; // x、y 的值均为97
      

    • 显式转换（即强制转换，当转换结果不适于目标变量时）

      byte x = '\u0101'; //不正确， '\0101'的Unicode码超出byte的范围
      byte y = (byte) '\u0101'; //正确，截取低8位，即0x01，y的值为整数1
      

  • 任意的数值类型可以转换成字符类型

    • 隐式转换（当转换结果适于char类型时）

    char ch1 = 97; // ch1的值为'A'
    char ch2 = 0x41; // ch2的值为'A'
    

    • 显式转换（即强制转换，当类型不匹配或数值超出char类型的范围时）

    char x = (char)50.25; //正确，截取整数值50，x的值为字符 '2'
    char y = (char)0xF0041; //正确，截取低16位，y的值为字符 'A'
    
    

  • Character类字符判别方法

    

• 字符串

  • String的比较方法

    

  • 获取，查找，替换子字符串

    • substring 方法（获取）

    • indexOf 方法（查找）

      

    • replace 方法（替换）

      

• 数字字符串与数值间的转换

  • 数字字符串转换为数值

    • • 数字字符串 -> int

      Integer. parseInt(String)
      

      • 数字字符串 -> float

      Float. parseFloat(String)
      

      • 数字字符串 ->double

      Double. parseDouble(String)
      

  • 数值转换为数字字符串

    • 将数值与一个空字符串连接

      20.5 + "" ;
      "" + 20.5 ;// 得到"20.5"
      

    • 用 String 类中的 valueOf 方法

      String.valueOf（ a ）,a 可以是任意的数值 、字符 或 字符串

      String value1 = String.valueOf(12); // int ->String:"12"
      String value2 = String.valueOf(12.0); // double  -> String:"12.0"
      String value3 = String.valueOf('9'); // char  -> String:"9"
      String value3 = String.valueOf('c'); // char  -> String:"c"
      

三、方法

• 定义方法格式

  • 方法头与方法签名

    • 方法头：指方法修饰符、返回值类型、方法名、方法的参数

    • 方法签名：指方法名称和参数列表（参数的类型、个数、顺序）

      

• 参数传递

  实参与形参占据不同的内存空间。因此，在方法内部改变形参的值，并不会影响到实参的值。

  

• 重载

  • 如果一个类中存在多个方法的名字相同，而这些方法的参数列表(参数的类型，顺序，个数)不同，这种现象称为重载。
  • 调用方法时，Java编译器寻找最精确匹配的方法进行调用。
  • 重载的方法可以改变访问修饰符
  • 重载的方法可以改变返回值的类型

四、数组

• 实例测试

          double[] scores = new double[10];
          System.out.println(scores); //[D@4554617c
  

  

  double[] scores只是声明，存的是数组scores[0]的引用值，是在栈中存储；
  new double[10]才是创建数组，为数组开辟的空间，在堆中。

• 声明数组：

  1.声明数组变量时，只是声明一个数组变量并为该变量分配内存，但没有给数组分配内存。

  2.创建数组后，数组变量的值只是数组的引用（内存中的首地址），不是包含所有数组元素！

• 数组一旦创建， 其大小不能改变，但是数组变量的值（引用）是可变的，可以引用具有不同大小的数组。

• 数组的默认值（缺省值）

  当数组被创建后，数组中的每个元素被赋予了一个 默认值（缺省值）,缺省值同数组的数据类型有关

  

• 数组的初始化

  • 类型标识符[] 数组名= new 类型标识符[] {初值表}

    int [] a=new int []{1,2,3}; //不能指定大小
    

  • 类型标识符[] 数组名= {初值表}

    int [] b={1,2,3};
    

• 数组的复制

  • 使用赋值语句复制数组是错误的

    

  • 真正的数组复制

    数组a与数组b需要占用不同的内存空间。

    • 使用循环逐元素复制

    • 使用 System 类的 arraycopy() 方法

      System.arraycopy(sourceArray, src_pos, targetArray, tar_pos, length);
      // sourceArray: 源数组
      // src_pos: 源数组中的起始位置
      // targetArray: 目标数组
      // tar_pos: 目标数组的起始位置
      // length: 要复制的数组元素的数量
      

• 将数组传递给方法

  • 在使用数组作参数时：

    1.实参与形参均为数组。
    2.在实际参数表中，数组名后不需括号，只需数组名。
    3.在形式参数表中，中括号不能省略，不需给出数组元素的个数。
    4.返回值只需数组名，返回值类型需要数组名加中括号。

  • 数组作参数时，传递的也是数组变量的值，但因为数组变量的值是数组的引用（即首地址）， 所以形参数组和实参数组指向相同的存储单元。此时形参数组中元素的改变将导致实参数组中对应元素的改变。

    

• Arrays类

  Arrays类是数组的操作类，定义在java.util.Arrays 类中，主要功能为实现数组元素的查找、排序和填充等

  

• 字符串转换为字符数组

  • 常用语法1：

     public String[] split(String regex) //参数regex：包含拆分字符的字符串 
    

  • 常用语法2：

    public String[] split(String regex, int limit) 
    //参数regex：包含拆分字符的字符串 
    //参数limit：拆分的份数 
    

  • 注意：
    1）若以 . | 和 * - 等为拆分字符，前面必须得加\
    2）若使用多个分隔符，可以用 | 间隔

            String src = "this is a split test";
            String array[] = src.split(" ");
    		//String array[] = src.split("\\.");  以"."分割
    		//String array[] = src.split("and|or"); 以and或or分割
            System.out.println("string: " + src);
            System.out.println("array:");
            for(int i = 0; i < array.length; i++) {
                System.out.println( i + ": " + array[i] );
            }
    

五、对象和类

• Java没有给方法中的局部变量赋予默认值。

• 静态变量：用 static 定义的类的属性，由类的所有实例所共享。

  

• 静态变量仅在第1次实例化对象时初始化，此后一 直贮存在静态区，直至程序退出。

• 可见性修饰符

  • 缺省修饰符：缺省情况下，类、变量或方法都是可以被同一个包内的任意类访问，而对另一个包的所有类不可见
  • 公共修饰符
    • 类、数据域或方法对任意包中的任意类可见
    • 可见性修饰符public可应用在类或类的成员上
    • 不能应用在局部变量上
  • 私有修饰符
    • 数据域或方法只能被声明它们所在的类访问，而在类的外部不能访问。
    • 可见性修饰符private只能应用在类的成员上
    • 不能应用在局部变量上
  • 保护修饰符
    • 同包，同类中可以访问。
    • 跨包必须是子类才能访问，子类可通过关键词super访问父类中的protected修饰的方法和属性。
      直接通过父类引用访问，不同包下，jvm解析不到是否是子类访问的情况，虽然你是在子类中定义了父类引用。通过super，jvm就知道是子类要访问父类的protected方法。

• 类的关系

  • 关联

    • 关联可以分为单向关联，双向关联

      

    • 一个教师可以开设一到三门课，一门课程有一 到多个教师教授。

      

  • 聚集和组合

    • 聚集(aggregation): 表示类之间一种松散的整体与部分的组成关系，是一种特殊的关联（ “has a” 关联 ）。没有了也没事

      

    • 组合(composition): 表示类之间一种紧密的整体与部分的 组成关系，也是一种特殊的关联，强调整体与部分不可分割。没有了就gg了

      

  • 类的泛化：表示事物之间的一般与特殊的关系。 也可以称为继承关系。

  • 类的依赖

    • 依赖(dependency): 表示两个元素X、Y，如果X的变化可能会导致Y的变化，则称Y依赖X。

      

    • 依赖关系是单向的

    • 依赖关系不仅限于类，用例、包、构件之间都可以存在依赖关系。

    • 依赖关系也称使用关系

      • 调用： 一个类调用另一个类的方法

      • 参数：一个类的方法使用另一个类作为形式参数

      • 发送： 消息的发送者与接收者之间的关系

      • 实例化： 一个类的方法中创建了另一个的实例。

        

  • 类的实现

    • 普通类实现抽象类

      

    • 普通类实现接口

• Java包装类

  • Java为每个基本类型提供了一个包装类

    

  • Integer常用方法

    

  • 基本类型与包装类间的转换

    

六、继承和多态

• 父类和子类

  • 子类能从父类中继承非私有的属性和方法(构造方法除外)。
  • 子类还可以添加自己特有的属性。
  • 子类不是父类的子集，子类通常比他的父类包含更多的东西。
  • 父类的私有数据域，无法再子类中访问，但是可以通过公共的访问器，间接访问。
  • 父类的构造方法不能被继承，但是会被子类显式或隐式地调用。当父类的构造方法没有被子类显式地调用时，则父类的无参构造方法自动被调用。

• 若在子类中定义与父类同名的成员变量， 则在该子类中父类的同名的成员变量被覆盖。

• 重写

  • 子类可以重新修改从父类中继承的方法，这叫做方法重写( method overriding )。
  • 方法重写条件：①签名相同（方法名、参数列表） ②返回值类型相同/兼容。
  • 实例方法只有在可被访问的情况下才可以被重写，父类的私有方法就不能被子类重写。
  • 方法重写时，如果在子类中定义的同名方法的可见性范围比在父类中的小，则会出现编译错误。
  • 静态方法也能被子类继承
    • 静态方法不能被子类覆盖
      
    • 父类中定义的静态方法在子类中重新定义，则父类的方法将被隐藏
      
    • 不能在静态方法中使用super
      
  • 可以使用重写标注来显式地强制子类重写父类的一个方法
    

• 多态

  • 多态意味着父类对象变量可以引用其子类对象,总是可以将子类的实例传递给需要父类类型的地方，形成多态性。
    

  • 当向上转型之后，父类引用变量可以访问子类中属于父类的属性和方法（为子类中的重写方法或继承的方法），但是不能访问子类独有的属性和方法(例如重载的方法)。

    public class Test2 {
        public static void main(String[] args) {
            A a=new B();
            a.test();//不加参数就会报错
            a.b;//报错
        }
    }
    
    
    class A{
        public void test(int a,int b){
            System.out.println("AAAAA");
        }
    }
    
    class B extends A{
    
        int b;
    
        public void test() {
            System.out.println("BBBBBBBBBBBB");
        }
    }
    

  • 声明类型 与 实际类型

    • 声明类型：一个变量必须被声明为某种类型。

      Person o
      

    • 实际类型：变量的实际类型,是被变量引用的对象的实际类型。

       o = new Student();
      

      

• 对象转换

  • 显隐式转换

    

  • 显式类型转换有可能失败

    使用instanceof 操作符可以测试一个对象是否是一个类的实例，得到结果是 boolean 类型。

    

  • 防止扩展和重写

    

七、异常处理与文本IO

• 异常与系统错误

  • 系统错误（system error） 是由Java虚拟机抛出并在Error类中描述的。 Error类描述内部系统的错误。 如果发生，除了通知用户以及尽量稳妥地结束程序外，几乎什么也不能做。
  • 异常（Exception）描 述由程序或外部环境引 起的错误，这些错误能 够通过程序捕获和处理
  • 运行时异常 （RuntimeException） 描述的是程序设计错误

  

• 必检异常和免检异常

  

  • 免检异常
    1. 大多数情况下，免检异常反映程序设计中不可恢复的逻辑错误。例如:
       - 通过一个未赋值的引用变量访问一个对象，会抛出 NullPointerException异常
       - 越界访问一个数组的元素就会抛出 IndexOutOfBoundsException异常
    2. 少数情况下表示JVM出现错误
       - Java 虚拟机调用资源出错，会抛出VirtualMachineError 异常（如内存空间不足）
    3. Java编译器不强制用户编写代码检查该类异常，并不是说程序代码没有问题不用修改
  • 必检异常
    • 编译器会强制程序员检查并处理它们

• 声明异常

  • 每个方法都必须声明它可能会抛出的必检类型的异常（对免检异常可由程序员决定是否声明）

    

  • 使用 throws 选项，声明可能会抛出的异常，可以声明多个异常，用逗号分开。

    

  • 在类的继承中，子类声明可能会抛出的异常类型不能在父类声明的异常类型范围之外。

    

• 抛出异常

  • 程序检查到一个错误后，可以创建一个异常类型的实例并抛出它，这就称为抛出异常。

  • 抛出异常使用 throw 语句，格式为： throw new 异常类名

  • throw语句一旦执行，将改变程序的正常执行流程，所在语句块中其后面的语句将不再被执行

    

• 捕获异常

  • 如果try块中出现异常，会跳过try块中剩余的语句

    

  • catch中异常的排列顺序是由小的异常类到大的异常类，如果父类异常的catch块排在子类异常的catch块之前，会导致编译错误。

    

  • 若匹配某一个catch子句，则执行其中的处理代码后跳出

    

八、抽象类和接口

• 抽象类

  • 特点：

    

  • 使用抽象类的目的：

    • 抽象类避免了该类被实例化，功能类似于“模板”
    • 增强了面向抽象编程思想，便于写出通用的代码（面 向对象设计的核心之一）
    • 只有抽象类才能容纳抽象方法（定义抽象类的目的之一）

  • 声明抽象方法：

    

  • 抽象类的非抽象子类必须给出每个抽象方法的具体实现，若有抽象方法在子类中没有被实现，该子类必须也必须声明为抽象。

  • 子类可以声明为抽象的，即使它的父类是具体的

• 接口

  • 为什么需要接口

    • Java语言的继承只能是单一结构 一个类最多只有一个父类，接口(interface)可以被用来实现多继承结构。
    • 接口指明多个类表现出的共同行为模式或特性。
    • 接口提供了方法声明与实现相分离的机制，每个实现接口的类可以根据各自要求，给出抽象方法的具体实现。

  • 接口的结构

    • 接口只包含常量和抽象方法

    • 成员变量只能是公有的、静态的常量

    • 接口中定义的方法都是公有的、抽象的

    • 在类中实现的抽象方法的可见性范围不能缩小

    • 在接口中，所有的数据域都是public final static的，所有的 方法都是public abstract的。 由于这个原因，这些修饰符可以忽略，如下所示：

      

  • Java 8 新方法

    

• 接口和抽象类

  • 接口可以继承接口而不是类（接口可以多重继承）
  • 接口和抽象类的异同
    • 相同点：都包含抽象方法 ，都不能被实例化
    • 不同点：
      1. 类只能单一继承自某个父类;接口可以继承多个接口
      2. 接口一般只包含常量和抽象方法(Java 8 可以有默认的实现方法)； 抽象类中可以包含成员变量、构造方法、抽象方法和普通方法。
      3. 接口中成员的可见性只能是public；抽象类中成员的可见性可以有多种可见性修饰符。
      4. 在接口里，数据必须是常量；抽象类可以有多种类型的数据
      5. 接口没有共同的根；所有的类共享同一个根：Object类。