java期末复习总结

Vector第二章

1、整数类型

8大数据类型，分为数值类型和布尔类型，数值类型分为整型和浮点类型。

数值：

（1）整数型

• byte：占一个字节，表示范围（-128~127）
• short：占两个字节，表示范围（-32768~32767）
• int：占四个字节，表示范围(-2~2-1)
• long:占8个字节，表示范围(-2~2-1)
• char:表示字符整型，2个字节，表示范围(0~65535)

(2)浮点型

• float：单精度浮点数，占4个字节，在内存中的存储满足IEEE 754标准，最高位存储符号，23~30位存储指数，0 ~22位存储尾数

• double：双精度浮点数，占8个字节，满足IEEE 754标准，最高位存符号，52-62存指数，0-51存尾数
  注：浮点数常量默认为double，声明float需要在数值后面添加f

（3）布尔型

• true(真)和false(假)，只能小写。

2、引用数据类型

java中的引用数据类型包含：类、接口、数组

（1）类与对象

• 类是具有相同属性与功能的对象的抽象
• 类对同种类型的不同对象的属性和功能进行封装
• 类是抽象的、对象是具体的，从类到对象就是从抽象到具体的过程
• 对象是类的实例，类是对象的抽象和一般化

（2）接口和实现类

• 接口可以包含属性和功能
• 除静态方法和默认方法外，接口中的其他方法必须是没有方法体的抽象方法
• 接口不能创建具体对象，只能通过其实现类创建

（3）数组

• 数组是一个对象
• 声明数组类型的变量是引用数据类型变量，是保存数组对象在内存中的地址

3、字符串

（1）定义

• java中用String类型定义和操作字符串对象
• 每一个字符串常量都是一个String类型的对象
• 字符窜类型的完整类名为java.lang.String，java.lang时包名，String是类名

（2）常用方法

 String str="1d4t4vv ";
        System.out.println(str.length());        //输出字符串长度8
        System.out.println(str.charAt(2));       //输出字符串索引为2的值4，从0开始到length-1
        System.out.println(str.indexOf('4'));    //输出字符4在字符串中的索引2，即第三个位置
        System.out.println(str.lastIndexOf('4'));//输出字符4在字符串最后的索引4
        System.out.println(str.substring(4));    //截取字符串索引为4~length-1的子串"4vv"
        System.out.println(str.substring(1,5));  //截取索引1~5的子串（不包括索引5的值）"d4t4"
        System.out.println(str.trim());          //去除字符串首尾多余的空格
        String[] s=str.split("4");               //以子串"4"分割字符串，返回一个字符串数组s["1d","4","t","v"]
        System.out.println(str.endsWith("vv ")); //判断字符串是否以"vv "结尾  true
        System.out.println(str.startsWith("2d"));//判断字符串是否以"2d"开始  false

4、输入与输出

（1）定义

• java中定义java.lang.System类提供标准输入和标准输出流对象
• System类不能实例化，在键盘上输入或向屏幕输出需要使用System类访问标准输入输出流对象System.in和System.out

（2）标准输入System.in

三种方法

        System.out.println(System.in.read());//读取从键盘上输入的一个字符
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println(br.readLine()); //读取从键盘上输入的一串字符串，读取到回车结束
        Scanner in=new Scanner(System.in);
        System.out.println(in.nextInt()); //读取一个整数，遇到空格或回车结束
        System.out.println(in.next());    //读取一串字符，遇到空格或回车结束
        System.out.println(in.nextLine());//读取一串字符，遇到回车结束，可读取空格

（3）标准输出System.out

String s="qingfan";
int a=12;
System.out.println(11);    //输出数字11，且自带换行
System.out.println(s);     //输出字符串qingfan
System.out.print(s);      //输出，不带换行
System.out.print(11);
System.out.printf("%s\n",s);
System.out.printf("%d",11);//输出数字11

5、数据转换

• 同类型转换成为同类转换
• 占字节数窄的转换为宽的类型成为变宽转换
• 占字节数宽的转换为窄的类型成为变窄转换

（1）基本数据类型转换

• 基本数据类型进行变宽转换时数据大小和精度不会丢失，属于隐式转换
• 一种整数型类型变宽时，变宽部分使用原数据中的符号位去填充，如byte b1=-12，补码1111 10100，变宽为short时高位全用符号位1填充
• 从int到float，从long到double或float都会出现精度丢失
• 数据进行变窄转换时，必须进行强制类型转换，又称隐式转换，会丢失数据大小和精度

（2）引用数据类型转换

隐式变宽：

• 从一个引用数据类型到其父类型或接口的转换都称为引用数据类型的变宽转换
• 从接口的实现类到接口的转换也是隐式变宽转换
• 一个引用数据类型的变量可以保存该类型的子类或实现类实例的引用

显示变窄：

• 从一个引用数据类型转到其子类或实现类的转换都称为数据类型的变窄转换
• 一个类型的引用数据变量保存其父类或接口的引用时必须进行显示强制转换

第三章

1、选择结构

（1）if-then-else

if(i>5){
    i--;
    System.out.println(i);
}else{
    System.out.println(j);
}

(2)switch-case

switch (i){
    case 1:
        System.out.println("wobushuai");
        break;
    case 9:
        System.out.println("wozuishuai");
        break;
    default:
        System.out.println("wohenshuai");
        break;
}

• i是表达式，表达式的返回类型可以是byte、short、char、int、enum、String
• 注意每一条case语句后都会跟一个break
• 为了保证书写规范，default后面也会跟一个break

2、循环结构

（1）for语句

for(int i=0;i<100;i++){
    //执行语句块
}
//for-each语句
        int[] a={1,2};
        for(int tem:a){
            System.out.println(tem);
        }

（2）while语句

while(j>0){
    //执行语句块
}

（3）do-while语句

do{
    //执行语句块
}while (j>0);

do-while语句先进入循环体，在进行条件判断，所以至少会执行一次

（4）break、continue

for(int i=0;i<100;i++){
    if(i==10){
        break;
    }
    if(i==10) {
        continue;
        System.out.println("qingfanbushuai");
    }
}
System.out.println("qingfanzuishuai");

• break语句直接跳出循环直接执行第10行代码

• continue语句会跳过i=10的那一次循环，继续执行f后续for循环，直到循环结束

a: for(int i=0;i<100;i++){
    for(int x=0;x<50;x++){
        if(i==10) {
            continue a;
        }   
     }
 }

标签语句

第四章

1、数组的定义

• java中数组是对象，属于引用数据类型
• 数组类型变量是引用数据类型变量，保存指向数组对象的引用
• 声明数组：类型名【】 变量名 ； 类型名 变量名【】；

2、数组的访问

• 一位数组：数组变量名 【索引】
• 二维数组：数组变量名 【索引】【索引】
• 索引下标都是0~length-1

int arr[][] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
};
for(int i=0;i<arr.length;i++){
    for(int j=0;j<arr[i].length;j++){
        System.out.println(arr[i][j]);
    }
}

第一行声明并初始化了一个二维数组，变量arr保存了一个三行三列数组的引用 6~9行进行数组访问，arr.length返回数组的行数，arr[i].length返回当前行数组的列数

3、参数的类型

• 方法首部的参数列表中的参数称为方法的形式参数
• 方法被调用时，由调用方法传递给被调方法的数据称为实际参数

第五章（重点）

1、面向对象编程

• 面向对象程序设计（OOD）是从面向对象的角度分析与设计程序的一种方法
• 将对象的属性和功能封装在类和接口中，对外只提供公开的方法

2、访问控制修饰符

• private：私有的，一级访问约束，只限制在当前类可以访问数据，包中的其他类及其子类以及其他包中的类都无法访问
• protected：受保护的，成员作用范围为当前类以及其子类
• defaul：包一级访问控制修饰符，成员作用范围是当前包中的所有类
• public：项目级访问约束，成员作用范围是当前项目中所有包中的所有类

3、构造方法

• 构造方法是类用于创建对象的一种特殊方法
• 与成员方法声明类似，具有访问修饰符，构造方法名，参数列表以及方法体
• 构造方法没有返回类型，并且方法名必须与类名相同
• 当构造方法的形参与成员变量相同时，形参会隐藏成员变量，必须在成员变量名前加上this.
• 创建类是不提供构造方法，编译器会自动添加一个不带形参的空构造方法，，反之若添加了带参数的构造方法，编译器就不会自动添加空构造方法
• 构造方法可以重载，不属于成员方法，不能继承

4、static成员和final成员

（1）static

• static关键字定义的成员变量和成员方法称为类的静态成员
• 类的静态成员属于类，不属于对象，在类的字节码文件加载后就会存在内存中
• 静态方法能访问当前类的静态成员变量和静态成员方法，不能访问类的实例成员变量和方法

（2）final

• final即可以修饰最终类，也可以修饰成员属性和方法
• 被final修饰的成员属性称为常量且不能修改，被final修饰的成员方法称为最终方法且不能重写

5、面向对象三大特征

（1）封装

• java通过类实现对数据和方法的封装，使用访问控制修饰符约束数据和方法的作用方位，一般用private
• 封装可以提高数据的安全性、方法的重用性，保护有效核心方法的具体实现
• 封装的数据在外通过getter和setter方法进行调用 命名规则：set+属性名/get+属性名 属性名首字母大写 如getName()

（2）继承

• 若存在一个部分属性和方法相同的类，则可以用这个类去创建新的类，这个类称为父类、基类、超类，新创建的类称为子类、派生类
• 子类与父类的关系称为继承或者泛化关系，子类通过extends关键字实现继承
• 子类可以直接或间接继承父类的所有public和protecd修饰的成员变量和方法
• java中出java.lang.Object类无父类外，其他类都有且仅有一个父类，可以有多个间接父类

（3）多态

• 同一类型的变量可以分别保存多种不同类型实例的引用，这就是多态的体现
• 父类类型的变量引用其子类的实例时，该变量需要先变窄为子类类型的引用才能访问子类的新增成员
• 从子类向父类或祖先类转换为隐式变宽转换，如Order order=new SalesOrder；
• 从父类或祖先类向子类转换为显示变窄转换，需要加强制转换符，如SalesOrder order=（SalesOrder）(new Order);
• 若两个类型在类继承上属于不同分支，则他们不能进行隐式或显示转换

public static class Order {
}
public static class OrderOne extends Order {
}
public static class OrderTwo extends OrderOne {
}
public static class OrderThree extends Order {
}
public static void main(String[] args) {
    Order order = new Order();                
    order = new OrderOne();                    //子类向父类转换，且同一类型变量可以保存不同类型的实例的引用
    OrderOne orderOne= (OrderOne) new Order(); //父类向子类转换
    OrderTwo orderTwo=new OrderThree();        //报错  不同分支的类型不能相互转换
}

6、接口（Interface）

• 接口包括常量、方法、默认方法、静态方法、内部类型
• 除默认方法和静态方法外，其余方法都是公共抽象方法，需要类实现，实现接口的类称为接口的实现类
• 接口中的常量默认为public static final，方法默认为public abstract
• 若类实现了接口及父接口中的所有抽象方法，则这个类是具体类，反之则是抽象类
• 接口不能实例化，必须通过实现类进行实现
• 接口可以继承一个或多个父接口
• 一个类只能继承一个父类，但是可以继承多个接口

public interface itf1 {
    int age = 0;  //public static final
    void play();  //public abstract
    default void play1(){   //默认方法 必须有方法体
    }
    static void play2(){    //静态方法，必须有方法体
    }
}
//类A是接口itf1的实现类，用关键字imple
  public abstract class A implements itf1{
    }

第六章

异常处理机制

1、throws

• 不在方法体内捕捉与处理异常，将可能产生的异常通过throws字句在方法首部进行消极处理
• 异常列表中的异常类型用逗号隔开
• 若有多个异常类型，可以只保留范围更宽的异常类型

public static void B() throws FileNotFoundException, IOException {
    FileOutputStream fos=new FileOutputStream(""); //FileNotFoundException
    System.in.read(); //IOException
}

IOException的范围比FileNotFoundException广，所以可以简化为

public static void B() throws IOException {
    FileOutputStream fos=new FileOutputStream(""); //FileNotFoundException
    System.in.read(); //IOException
}

2、try-catch-finaly

public static void B() throws IOException {
    try {
        FileOutputStream fos=new FileOutputStream(""); //FileNotFoundException
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } 
    try {
        System.in.read(); //IOException
    } catch (IOException e) {
        e.printStackTrace();
    }finally {
        //异常处理程序的退出语句，可以用于恢复或释放资源
        System.in.close();
    }
}

3、try-with-resource

public static void C() throws IOException {
    try(FileOutputStream fos=new FileOutputStream("")) {
       //try-with-resource语句块 
    }
}

• 执行完毕后自动调用close方法关闭资源
• 可以保存所有被抑制的异常，用getSuppressed方法返回

第七章

1、常用接口

• Iterable：实现Iterable接口的类型允许使用for-each语句迭代访问其中的元素
• Iterator：Iterator迭代器和循环语句可以用于集合遍历
• ListIterator：Iterator的子接口，允许对List集合进行双向访问和修改
• Collection：集合框架的根接口，继承Iterable接口
• Set
• List
• Map
• Queue

2、Set接口及其实现类

（1）概念

• Set接口是Collectio的子接口，允许存放多个不重复元素，且存放数据无序
• 两个实现类：HashSet、LinkedHashSet、SortedSet
• TreeSet继承SortedSet，常用TreeSet

（2）set接口常用方法

Set<Integer> set = new HashSet<>();
Set<Integer> set1 = new HashSet<>();
set.add(10);  //增加元素
set.add(20);
set.add(30);
set1.add(40);
System.out.println(set.size());           //返回set集合大小 3
System.out.println(set.isEmpty());        //判断set集合是否为空
System.out.println(set.contains(10));     //判断set集合是否含有值10  true
System.out.println(set.remove(10));       //删除集合中元素50，并返回是否成功  false
System.out.println(set.containsAll(set1));//判断set集合是否包含set1集合中的所有的元素
set1.addAll(set);                         //将set集合中的所有元素复制到set1中
Object[] arr=set.toArray();               //将set集合中的所有元素转到arr数组中
//遍历set集合的方法
//1.使用增强for循环直接遍历
for(Integer tem:set){
    System.out.println(tem);
}
//2.使用Iterator迭代器
Iterator<Integer> iterator=set1.iterator();
for(;iterator.hasNext();){
    System.out.println(iterator.next());
}

3、List接口及其实现类

（1）概念

• List接口是Collectio的子接口，允许存放重复元素，能按索引插入和访问元素，存放的数据是有序的
• List接口提供的ListIterator迭代器对集合进行插入、替换、双向访问操作
• 实现类：Vector、Stack、ArrayList、LinkedList

（2）接口常用方法

List<Integer>list=new ArrayList<>();
list.add(10);  //向list集合中添加元素
list.add(20);
list.add(10);
System.out.println(list.size());       //返回集合大小 3
System.out.println(list.contains(10)); //判断集合中是否含有10这个元素  true
System.out.println(list.get(1));       //获取集合索引下标为1的值（0~length-1） /20
System.out.println(list.isEmpty());    //判断集合是否为空  false
System.out.println(list.indexOf(20));  //输出20在集合中的索引位置，没有则返回-1  /1
System.out.println(list.lastIndexOf(10)); //返回10在集合最后的位置，不存在返回-1  /2
list.add(30);                               //在集合尾部添加元素30
list.add(1,40);                       //在索引为1的位置处添加元素40
list.remove(0);                       //删除索引为0的值
System.out.println(list.remove(1));   //返回索引为1的值，并删除  20
System.out.println("-----------");
//遍历集合的方法
//1.通过增强for循环直接遍历
for(Integer tem:list){
    System.out.println(tem);  //40 10 30
}
//2.通过迭代器ListIterator或者Iterator，前者为双向操作
ListIterator<Integer> listIterator=list.listIterator(); //双向遍历
while (listIterator.hasNext()){
    System.out.println(listIterator.next());            //向后遍历 40 10 30
}
for(;listIterator.hasPrevious();){
    System.out.println(listIterator.previous());        //从后向前遍历 30 10 40
}
list.clear();        //清空list集合

4、Map接口及其实现类

（1）概念

• Map允许存放多个键值对数据，其中键不允许重复，且存储的数据没有顺序
• 实现类：HashMap、HashTable、TreeMap
• TreeMap可以按照键值对值的大小从小到大存储元素，有序

（2）接口常用方法

Map<Integer,String> map1=new HashMap<>();
Map<Integer,String> map2=new HashMap<>();
map1.put(1,"qing");      //向map中增加键值对
map1.put(2,"fan");
map2.put(3,"hen");
System.out.println(map1.size());   //输出map集合的大小 2
System.out.println(map1.get(1));   //获取键为1的map的values值 qing
System.out.println(map1.containsKey(2));          //判断map集合中是否含有键值为2的键值对     true
System.out.println(map1.containsValue("shuai"));  //判断map集合中是否含有值为"shuai"的键值对 false
System.out.println(map1.isEmpty());               //判断map集合是否为空 false
map2.putAll(map1);                                //将map1的所有值复制到map2中
//遍历map集合的方法
//1.通过keySet返回所有的键，在通过调用get方法获取值
Set<Integer> keyset= map2.keySet();
for(Integer id:keyset){
    System.out.println(id+"--"+map2.get(id));   //键值有1 2 3
}
//2.调用enterSet方法返回所有的键值对
for(Map.Entry<Integer,String> entry:map1.entrySet()){
    int key=entry.getKey();
    System.out.println(key+"--"+entry.getValue());  //键值有1 2
}
 map2.remove(2);                //删除map集合中键值为2的键值对
//3.通过values方法返回所有值
for(String value:map2.values()){
    System.out.println(value);  //键值有1 3
}
map1.clear();  //清空map集合

第八章

1、流的继承关系

InputStream： 字节输入流

• FileInputStream
• ObjectInputStream
• InputStreamReader
• ByteArrayInputStream
• SequenceInputStream

OutputStream： 字节输出流

• FileOutputStream
• ObjectOutputStream
• OutputStreamWriter
• FilterOutputStream

Reader： 字符输入流

• BufferedReader
• CharArrayReader
• FilterReader
• StringReader

Writer： 字符输出流

• BufferedWriter
• CharArrayWriter
• FilterWriter
• StringWriter
• PrintWriter