java复习笔记

阳光穿透心脏的1/2处 2022-10-02 05:46 143阅读 0赞

### java复习笔记 ###

*  java概述
 *  java语言基础
 *  面向对象基础
 *  核心类
 *  类之间的关系
 *  抽象类和接口
 *  异常
 *  泛型与集合

# java概述 #

*  Java语言优势  
    资源免费、跨平台、健壮、安全、高性能  
    简单、面向对象、动态性、多线程
 *  专有名词  
    JDK JRE JVM SDK
 *  垃圾回收特点  
    内存优化、动态回收、回收的不确定性、占用系统开销
 *  JDK目录  
    bin：JDK包中命令及工具所在目录  
    jre：运行环境目录  
    lib：类库所在目录  
    db：附带数据库目录  
    include：包含本地代码的C头文件的目标  
    src.zip：源代码压缩文件
 *  JDK常用工具  
    javac：Java语言编译器  
    java：Java字节码解释器  
    javadoc：文档生成器  
    javap：Java字节码分解程序  
    javah：Jni编程工具  
    appletviewer：小应用程序浏览工具  
    jar：打包程序
 *  注释

单行注释 //单行注释
    多行注释 /*多行注释*/
    文档注释 /**文档注释*/

# java语言基础 #

*  数据类型
    
     *  基本类型是一个单纯的数据类型，表示一个具体的数字、字符或布尔值
     *  引用类型是一个复杂的数据结构，是指向存储在内存的“堆”中数据的指针或引用（地址）
 *  字符型  
    char 大小：16位 取值范围：‘\\u0000’~‘\\uFFFF’
 *  补码的计算规则  
    1.正数的补码和原码完全相同  
    2.负数的补码是其反码加1，反码是对原码按位取反，其中最高位符号位保持不变
 *  算数运算  
    如果/和%的两个操作数都是整数类型，则除数不能是0，否则引发除以0异常。但如果两个操作数有一个是浮点数，或者两个都是浮点数，此时允许除数是0或0.0，任何数除0得到的结果是正无穷大（Infinity）或负无穷大（-Infinity），任何数对0取余得到的结果是非数：NaN。
 *  位运算符 >>>  
    无符号右移，无论正数还是负数，无符号右移后左边空出来的位都填充0
 *  关系运算符 ==  
    1.如果进行比较的两个操作数都是数值类型，即使它们的数据类型不同，只要它们的值相等，都将返回true。  
    例如’a’ == 97返回true，5 == 5.0也返回true。  
    2.如果两个操作数都是引用类型，则只有当两个引用变量的类型具有继承关系时才可以比较，且这两个引用必须指向同一个对象（地址相同）才会返回true。  
    3.如果两个操作数是布尔类型的值也可以进行比较。  
    例如true == false返回false。
 *  “短路运算”功能  
    &&运算符检查第一个操作数是否为false，如果是false则结果必为false，无需检查第二个操作数。||运算符检查第一个表达式是否为true，如果是true则结果必为true，无需检查第二个操作数。检查其他内容。因此，对于&&当第一个操作数为fasle时会出现短路；对于||当第一个操作数为true时会出现短路。
 *  switch语句  
    1.switch语句后面的控制表达式的数据类型只能是byte、short、char、int四种类型  
    2.但从Java 7开始允许枚举类型和String字符串类型
 *  数组  
    int a\[10\]=\{ 0,1,2,3,4,5,6,7,8,9 \}; × 是不被允许的

# 面向对象基础 #

*  面向对象  
    面向对象的分析（OOA）  
    面向对象的设计（OOD）  
    面向对象编程（OOP）
 *  面向对象特征  
    唯一性  
    分类性  
    继承性  
    多态性
    
     *  多态性是指相同的操作、过程可作用于多种类型的对象上并获得不同的结果。
     *  不同的对象，收到同一消息可以产生不同的结果，即具有不同的表现行为，这种现象称为多态性。
 *  方法的参数传递机制  
    值传递：实参和形参在内存中占不同的空间，当实参的值传递给形参后，两者之间将互不影响  
    在Java中，当参数的数据类型是基本数据类型时，实参和形参之间会是按值传递的。  
    引用传递：是将实参的“地址”传递给形参，被调方法通过传递的地址获取其指向的内存空间，从而在原来内存空间直接进行操作。  
    在Java中，当参数的数据类型是引用类型时，如类、数组，实参和形参之间会是按引用传递的
 *  可变参数

语法：
    [访问符] [修饰符] <返回类型> 方法名([参数列表],数据类型… 变量) { 
    	//方法体
    }
    实例：
    public int add(int a, int... b) { 
    	//......省略
    }

1、可变参数只能处于参数列表的最后；
    2、一个方法中最多只能包含一个可变参数；
    3、可变参数的本质就是一个数组，因此在调用一个包含可变参数的方法时，既
    可以传入多个参数，也可以传入一个数组。

*  java中的访问修饰符有：public、protected、缺省、private

# 核心类 #

*  从JDK1.5之后，Java提供了自动装箱（Autoboxing）和自动拆箱（AutoUnboxing）功能，因此，基本类型变量和封装类之间可以直接赋值
 *  装箱于插箱  
    装箱是指将基本类型数据值转换成对应的封装类对象，即将栈中的数据封装成对象存放到堆中的过程  
    拆箱是装箱的反过程，是将封装的对象转换成基本类型数据值，即将堆中的数据值存放到栈中的过程
 *  基本类型的值转换成字符串有三种方式：  
    直接使用一个空字符串来连接数值即可，例如：""+23  
    调用封装类提供的toString()静态方法，例如：Integer.toString(100)  
    调用String类提供的valueOf()静态方法，例如：String.valueOf(66)
 *  字符串的值转换为基本类型的值有两种方式  
    直接利用封装类的构造方法，即Xxx(String s)构造方法  
    调用封装类提供的parseXxx(String s)静态方法
 *  “= =”运算符和equals()方法区别：  
    “= =”运算符比较的是两个对象地址是否相同，即引用的是同一个对象。  
    equals()方法通常可以用于比较两个对象的内容是否相同。
 *  Object类中的toString()方法返回：类名@哈希代码值
 *  线程安全  
    线程安全就是多线程访问时，采用了加锁机制，当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。  
    线程不安全就是不提供数据访问保护，有可能出现多个线程先后更改数据造成所得到的数据是脏数据。
 *  String、StringBuffer和StringBuilder  
    String创建的字符串是不可变的，如果改变字符串变量的值，是在内存中创建一个新的字符串，字符串变量将引用新创建的字符串地址，而原来的字符串在内存中依然存在且内容不变，直至Java的垃圾回收系统对其进行销毁。  
    StringBuffer创建的字符串是可变的，当使用StringBuffer创建一个字符串后，该字符串的内容可以通过append()、insert()、setCharAt()等方法进行改变，而字符串变量所引用的地址一直不变，最终调用它的toString()方法转换成一个String对象。  
    StringBuilder与StringBuffer类似也是创建一个可变的字符串，不同的是StringBuffer是线程安全的，而StringBuilder没有实现线程安全，因此性能较好。
 *  在Java程序中，经常使用“+”运算符连接字符串

# 类之间的关系 #

*  关系  
    继承(添加自己的特有功能。继承也称为泛化，表现的是一种共性与特性的关系)  
    实现(类实现一个或多个接口)  
    依赖(方法中操作另外一个类的对象)  
    关联(使用类作为成员变量)  
    聚合：是整体与部分的关系，通常表现为一个类（整体）由多个其他类的对象（部分）作为该类的成员变量，此时整体与部分之间是可以分离的，整体和部分都可以具有各自的生命周期  
    组成：是比聚合关系要求更高的一种关联关系，体现的也是整体与部分的关系，但组成关系中的整体与部分是不可分离的，整体的生命周期结束后，部分的生命周期也随之结束
 *  Java只支持单一继承
 *  实例化一个子类对象时，会先调用父类构造方法进行初始化，再调用子类自身的构造方法进行初始化
 *  final关键字  
    当final关键字修饰变量时，表示该变量是不可改变的量，即常量；  
    当final关键字修饰方法时，表示该方法不可被子类重写，即最终方法；  
    当final关键字修饰类时，表示该类不可被子类继承，即最终类
 *  引入内部类的原因  
    内部类能够隐藏起来，不为同一包的其他类访问；  
    内部类可以访问其所在的外部类的所有属性；  
    在回调方法处理中，匿名内部类尤为便捷，特别是事件处理经常使用。
 *  成员内部类  
    定义：在“外部类”的内部定义一个类
 *  局部内部类  
    局部内部类不能用public或private访问修饰符进行声明  
    局部内部类作用域被限定在声明该类的方法块中  
    局部内部类的优势在于，它可以对外界完全隐藏起来，除了所在的方法之外，对其他方法而言是不透明的  
    局部内部类不仅可以访问包含它的外部类的成员，还可以访问局部变量，但这些局部变量必须被声明为final
 *  静态内部类  
    定义：使用static关键字修饰一个内部类，则该内部类称为“静态内部类”  
    静态内部类属于外部类的本身，而不属于外部类的某个对象
 *  匿名内部类  
    匿名内部类就是没有名字的内部类。匿名内部类适合只需要使用一次的类，当创建一个匿名类时会立即创建该类的一个实例，该类的定义会立即消失，不能重复使用  
    1、匿名内部类不能有构造方法；（没有类名）  
    2、匿名内部类不能定义任何静态成员、方法和类，但非静态的方法、属性、内部类是可以定义的；  
    3、只能创建匿名内部类的一个实例；  
    4、一个匿名内部类一定跟在new的后面，创建其实现的接口或父类的对象。
 *  单例模式（Singleton设计模式）是系统中生成某种类型的对象有且只有一个
 *  单例模式实现方式：  
    构造方法私有；  
    用一个私有的静态变量引用实例；  
    提供一个公有的静态方法获取实例。

# 抽象类和接口 #

*  抽象类和抽象方法必须使用“abstract”关键字来修饰。
 *  定义抽象类和抽象方法的规则如下：  
    abstract关键字放在class前，指明该类是抽象类；  
    abstract关键字放在方法的返回类型前，指明该方法是抽象方法，抽象方法没有方法体；  
    抽象类不能被实例化即无法使用new关键字直接创建抽象类的实例，即使抽象类中不包含抽象方法也不行；  
    一个抽象类中可以含有多个抽象方法，也可以含有已实现的方法；  
    抽象类可以包含成员变量以及构造方法，但不能通过构造方法创建实例，可在子类创建实例时调用；  
    定义抽象类有三种情况：直接定义一个抽象类；或继承一个抽象类，但没有完全实现父类包含的抽象方法；或实现一个接口，但没有完全实现接口中包含的抽象方法。
 *  private和abstract不能同时修饰方法。abstract也不能和static、final或native同时修饰同一方法。
 *  接口和抽象类有很多相似之处，都具有如下特征：  
    接口和抽象类都不能被实例化，需要被其他类实现或继承；  
    接口和抽象类的类型变量都可以指向其实现类或子类的实例对象；  
    接口和抽象类都可以包含抽象方法，实现接口或继承抽象类时都必须实现这些抽象方法。
 *  接口和抽象类区别:  
    1.接口体现的是一种规范，这种规范类似于总纲，是系统各模块应该遵循的标准，以便各模块之间实现耦合、以及通信功能；  
    2.抽象类体现的是一种模版式设计。抽象类可以被当成系统实现过程中的中间产品，该产品已实现了部分功能但不能当成最终产品，必须进一步完善，而完善可能有几种不同方式。  
    3.接口中除了默认方法和类方法，不能为普通方法提供方法实现（没有方法体）；而抽象类则完全可以为普通方法提供方法实现；  
    4.接口中定义的变量默认是public static final，且必须赋初值，其实现类中不能重新定义，也不能改变其值，即接口中定义的变量都是最终的静态常量；而抽象类中的定义的变量与普通类一样，默认是缺省，其实现类可以重新定义，也可以根据需要改变其值；  
    5.接口中定义的方法都默认缺省的是public，而抽象类则与类一样是默认缺省的；  
    6.接口不包含构造方法，而抽象类可以包含构造方法，抽象类的构造方法不是用于创建对象，而是让其子类调用以便完成初始化操作；  
    7.一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口；一个接口可以有多个父接口。
 *  接口体内定义的常量、方法等都默认为public
 *  instanceof关键字

Java的多态性机制导致了声明的变量类型和实际引用的类型可能不一致，同种
    类型的两个引用变量调用同一个方法时也可能会有不同的行为。为更准确的鉴别
    一个对象的真正类型，可以使用instanceof关键字进行判断。
    
    语法：引用类型变量 instanceof 引用类型
    
    “instanceof”关键字用于判断前面的“引用类型变量”是否是后面的“引用类型”
    ，或者其子类、实现类的实例；如果是，则返回true，否则返回false。

# 异常 #

*  这种在运行时出现的意外错误称为“异常”
 *  Throwable是所有异常类的父类，Error和Exception都继承此类
 *  Exception异常从编程角度又可以分为以下两种类型：  
    非检查型异常：编译器不要求强制处置的异常，该异常是因编码或设计不当导致的，这种异常可以避免，RuntimeException及其所有子类都属于非检查型异常  
    检查型异常：编译器要求及其子类（RuntimeException及其子类除外）都属于检查型异常必须处理的异常，该异常是程序运行时因外界因素而导致的，Exception
 *  Java提供的异常处理机制有两种：  
    使用try…catch捕获异常：将可能产生异常的代码放在try语句中进行隔离，如果遇到异常，程序会停止执行try块的代码，跳到catch块中进行处理。  
    使用throws声明抛出异常：当前方法不知道如何处理所出现的异常，该异常应由上一级调用者进行处理，可在定义该方法时使用throws声明抛出异常。
 *  多异常捕获

从Java 7开始，一个catch块可以捕获多种类型的异常
    
    语法：
    try { 
    	//业务实现代码(可能发生异常)
    	......
    }
    catch (异常类A [|异常类B ...|异常类N] 异常对象) { 
    	//多异常捕获处理代码
    }
    ......//可以有多个catch语句
    
    其中：
    捕获多种类型的异常时，多种异常类型之间使用竖杠“|”进行间隔；
    多异常捕获时，异常变量默认是常量，因此程序不能对该异常变量重新赋值。

*  自定义异常类都继承Exception或RuntimeException类

# 泛型与集合 #

*  实例化泛型类时只需给出一对尖括号“<>”即可

类名<类型参数列表> 对象 = new 类名<> ([构造方法参数列表]);
    Node<String> myNode = new Node<> ();

*  有界类型  
    使用extends关键字声明类型参数的上界；  
    使用super关键字声明类型参数的下界。
 *  通配符是由“?”来表示一个未知类型，从而解决类型被限制、不能动态根据实例进行确定的缺点。
 *  Java对泛型的限制如下：  
    泛型的类型参数只能是类类型（包括自定义类），不能是简单类型；  
    同一个泛型类可以有多个版本（不同参数类型），不同版本的泛型类的实例是不兼容的，例如：“Generic”与“Generic”的实例是不兼容的；
 *  Java的集合类主要由两个接口派生而出：Collection和Map，这两个接口派生出一些子接口或实现类。
 *  Java中的集合分为三大类：  
    Set集合：将一个对象添加到Set集合时，Set集合无法记住添加的顺序，因此Set集合中的元素不能重复，否则系统无法识别该元素，访问Set集合中的元素也只能根据元素本身进行访问；  
    List集合：与数组类似，List集合可以记住每次添加元素的顺序，因此可以根据元素的索引访问List集合中的元素，List集合中的元素可以重复且长度是可变的；  
    Map集合：每个元素都是有key/value键值对组成，可以根据每个元素的key来访问对应的value，Map集合中的key不允许重复，value可以重复。
 *  可以将Map集合转换为Collection集合
 *  Java集合框架中还提供了两个非常实用的辅助工具类：Collections和Arrays