Java复习总结

最新推荐文章于 2023-06-22 12:54:35 发布

StarryTank

最新推荐文章于 2023-06-22 12:54:35 发布

阅读量440

点赞数

分类专栏： Java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_55085530/article/details/122126351

版权

Java 专栏收录该内容

34 篇文章 1 订阅

订阅专栏

1 面向对象(1)

1.在判断访问权限时，要首先判断类的权限，再判断数据成员，方法的权限。
2.Java程序分为Application和Applet，首先都通过javac命令编译成字节码文件，Application通过java解释器执行Java字节码文件，独立运行，Applet不能独立运行，需要依赖浏览器，用appletviewer工具来调试。
3.数组的长度：arr.length
4.字符串的长度 str.length()
5.toString方法返回该对象的字符串，便于输出
输入十个整数求最大值与最小值

public class test{
public static void main(String[] args)throws IOException{
      System.out.println(“请输入10个整数,并用空格隔开:”);
      //将字节流转化为字符流
      BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
      //读取一行字符串
      String s=in.readLine();
      //int a=s.length();
      //将字符串以空格切割,并且用字符串数组存储
      String[] nums=s.split(" ");
      int minNum=Integer.parseInt(nums[0]);
      int maxNum=Integer.parseInt(nums[0]);;
      Integer num=1;
      String s1=num.toString();
      System.out.println(“s1=”+s1);
      for(int i=1;i<nums.length;i++){
      minNum=Math.min(minNum,Integer.parseInt(nums[i]));
      maxNum=Math.max(maxNum,Integer.parseInt(nums[i]));
     }
     System.out.println(“最小值:”+minNum);
     System.out.println(“最大值:”+maxNum);
   }
}

子类对象初始化顺序:
1、为子类对象分配内存空间，对成员变量进行默认的初始化。
2、调用与传入参数对应的子类构造方法，将new中的参数传递给构造方法的形式参数。
3、显式或隐式调用super方法，进行父类初始化方法。
4、执行初始化字段，最后进行子类初始化方法的剩余语句。
注意：父类优先初始化，会调用super方法，若父类有有参构造方法，默认无参构造需自己写
抽象类被类实现时，抽象方法必须被覆写。
抽象类可以有构造函数与成员变量，可以有声明，但是不能实例化对象。
抽象类在被具体类继承时，具体类要实现所有的抽象方法，如果被抽象类继承时，则可以不用。
覆写方法：非static,final,构造方法

2 面向对象（2）

2.1接口(Interface)：

接口的两种含义:API,方法说明的集合
接口定义的注意事项：
1接口定义用关键字interface,interface前面的修饰符只能是public，或者缺省
2 一个类可以同时实现多个接口，用implements关键字
3 接口可以继承，而且可以多继承
4 接口定义的数据全部是public final static,使用接口名或实现类名访问
5 如果实现某接口的类不是abstract修饰的抽象类，是具体类，则在类的定义部分必须实现接口的所有抽象方法，而且方法头部分应该与接口中的定义完全一致。如果实现接口的类是abstract类，则它可以不实现该接口的所有方法。但对于抽象类的任何一个非抽象的子类而言，接口中的所有抽象方法都必须实现。
6 接口没有构造方法，其所有方法都为public abstract方法类在实现接口的抽象方法时，必须显式使用public修饰符，否则将被警告为缩小了接口中定义的方法的访问控制范围。

2.2引用

1引用如何形成：先声明，后初始化（将对象赋给引用）
2抽象类声明可以引用所有具体子类对象，此概念可以推广到所有具有父子关系的类，以及接口和实现类。
3替换是有原则的：父类引用可以指向子类对象，子类声明不能引用平行级别的其它类的对象,也不能引用父类对象。
4父类声明引用子类对象，子类类型到父类类型，可以自动向上转型，通过子类的引用可以调用只存在于子类中的方法，通过父类引用可以只能调用父类可见的方法，即父类与子类共有的方法。
5 父类引用子类对象，可以通过强制显示向下转型，获得子类引用。

2.3引用比较

2.3.1 equals方法: equals方法是Object类的方法，比较本引用和参数指明的某个引用是否相等，即是否指向同一对象。返回true或false。很多Object的子类对其进行了覆盖，并实现了不同的功能例如：String类对equals方法进行了覆盖，比较两个字符串对象的内容是否相等，而不是比较引用是否指向同一个字符串对象

有时自定义类需要对equals方法进行override覆写。
2.3.2 比较:如果两边是对象引用则比较的是它们的引用是否相同；如果两边是数值，则比较的是它们的值(如果值类型不同，有可能发生类型转化，例如1010.0将返回true)；如果一边是引用，一边是值，则编译错误。
2.3.3 instanceof：二元运算符。用法：boolean result = object instanceof class判断对象是否为特定类的实例
避免向下转型时抛出运行时异常

2.4内部类，匿名对象，匿名内部类

内部类就是在某个类的内部又定义了一个类，内部类可以直接访问外部类的所有成员
匿名对象就是在产生对象时没有显示地为这个对象建议引用 new Person.shout()，匿名对象在两种情况下经常使用：如果对一个对象只需要进行一次方法调用。将匿名对象作为参数传递给一个函数调用
匿名内部类: 匿名内部类就是在类中需要实例化这个类的地方创建一个匿名类，通常在方法内，必须继承一个父类或实现一个接口，但最多只能继承一个父类，或者实现一个接口，产生的是一个没有名字的类/接口的子类对象
格式一：
new 类A（） {
方法体
}
此时产生的对象是类A的子类对象。
格式二：
new 接口A（） {
方法体
}
此时产生的对象是接口A的实现类对象

 new Thread(()->{
            System.out.println("start a new Thread");
        }).start();

3 异常

为什么要处理异常?
正常情况以外的事件，具有不确定性。遇到异常后，程序不能正常向下执行。

3.1异常分类

两者都继承Object类，然后是Throwable类
Error:致命异常，标识系统发生了不可控的错误，程序无法处只能人工介入，StackOverflowError、OutOfMemoryError。
程序会终止，Error是所有错误类的祖先类
Exception: 非致命异常。程序可处理。分为受编译器检测的checked异常（受检异常）和不受编译器检测的unchecked异常（非受检异常）。可以由程序捕获或处理,程序不会终止，Exception是所有异常类的祖先类,分为checked异常与unchecked异常(RuntimeException类)

3.2异常处理

在这里插入图片描述

3.2.1显示声明抛出
当某一个方法中的代码可能发生异常，且异常不属于RuntimeException,则必须要显示声明抛出异常，或者使用try-catch-finally语句进行异常捕获，谁调用该方法谁进行处理。例:throws IOException
特别的，若main方法抛出异常则将异常抛给Java虚拟机进行处理
3.2.2隐式声明抛出
若异常是unchecked异常类型（RuntimeException及其子类），则throws声明子句可省略，会自动隐式的抛出异常。
例如:算术异常，空指针异常，类转换异常，数组越界异常等
3.2.3捕获处理
异常处理是由try －catch组成的一个异常处理块结构，最为完整的方式是try-catch-finally语句
在这里插入图片描述

由于可能会出现多个代码块抛出异常，所以可以由多个catch捕获处理多个异常，注意，多catch情况：异常类由上到下排布规则是由子到父，由具体到抽象，或为并列关系。执行过程类似于switch case（仅会执行一个）。若无异常发生，则都不执行。Finally代码不管是否由异常发生都会执行，finally代码块在return语句运行后执行的。return结果被暂存，等finally代码块执行结束后再将之前暂存的结果返回
finally用途:
一般用来进行一些善后清理操作，
例如清理资源、释放连接、关闭文件、I/O流等操作。

3.3自定义异常与异常对象

异常对象大部分由系统产生；在编程时也可以主动产生异常，相应的语句为：throw new 异常类；//运行时抛出异常
new后面的异常类可以是JDK中已定义的异常，也可以是自定义异常（继承某个异常类的自定义异常类）。
注意：throw语句与throws声明的区别

4字符串

4.1 String

4.1.1String对象的构造与初始化
String 不是简单类型，而是一个类，它被用来表示字符序列。
字符本身符合 Unicode 标准，其基本的初始化方式如下：
==方式一：String s1 = “abc”; //字符串常量池
方式二: String s2 = new String(“abc”); //堆 ==
String str = new String(“abc”);
在这里插入图片描述
4.1.2 String对象的特点
String对象是不可变的，在String类中每一个看起来会修改String对象内容的方法，实质都是创建了一个全新的String对象。
4.1.3 String 作为参数传递的特点
字符串是一个特殊的数据类型，它的底层是一个final 型的ch[]数组，属于无法更改，所以字符串在作为参数传递时，可以当做一个特殊的数组进行操作，同样的它也是将复制一份原本的对象引用给了副本，此时副本对象的引用和原本对象的引用都指向原始字符串的位置，也就是s1和在刚开始初始化时它指向的地址和原对象s指向的位置一致，
尽管是传引用，但通过形参引用并未改变实参指向的字符串内容
4.1.4 String设计成不可变性的好处:
兼顾效率&安全

字符串常量池的需要
String哈希码（hashcode）的唯一性，可缓存
String多线程安全
String常作为参数传递（网络、数据库，安全性）

4.2 StringBuffer

StringBuffer对象的值是可变的，对字符串的增加、插入、修改、删除等操作比String高效（不需多次创建新的对象）。

public class Str {
   public void changePara(String s){
     s  = s +"a";
   }
   public void invoke(){
     String s ="b";
     changePara(s);
     System.out.println(s); 
   }
   public static void main(String[]str){
     Str s = new Str();
     s.invoke();   
   }
}

输出结果：b

public class Str {
  public void changePara(StringBuffer s){
     s  = s.append("a");
  }
  public void invoke(){
    StringBuffer s =new StringBuffer("b");
    changePara(s);
    System.out.println(s);
  }

输出结果:ba
StringBuffer底层char[] value; //常量字符数组

4.3 StringBuilder

JDK5 引入了StringBuilder，其与StringBuffer的 API兼容，性能比StringBuffer更高，但不是线程安全的。
StringBuilder与String字符串的拼接比较:
在这里插入图片描述

4.4 String、StringBuffer、StringBuilder 比较

String、StringBuffer、StringBuilder相同点:
1.内部实现基于字符数组，封装了对字符串处理的各种操作
2.可自动检测数组越界等运行时异常
String、StringBuffer、StringBuilder不同点：
1.String内部实现基于常量字符数组，内容不可变； StringBuffer、StringBuilder基于普通字符数组，数组大小可根据字符串的实际长度自动扩容，内容可变
2. 性能方面，对于字符串的处理，相对来说StringBuilder > StringBuffer > String
3.String,StringBuffer线程安全；StringBuilder非线程安全
StringBuffer与StringBulider均可通过toString方法转化为String类型

5 I/O输入输出

输入与输出流以目标对象为中心，例如文件，键盘，屏幕，数组，向对象中写入数据为输出流，向对象中读数据为输入流。
而键盘只有输入流，屏幕只有输出流
从读取类型上分：一般分为字节流和字符流
字节流 InputStream，OutputStream（抽象类），由它们派生出来的一系列类，它以字节(byte)为基本处理单位。
byte里面存的是unicode码，需要强制转换为char
字符流
Java的标准输入输出流
标准输入,对象是键盘,Java对应类是System.in。
标准输出,对象是屏幕,Java对应类是System.out。

5.1 InputStream方法：

在这里插入图片描述

5.2 OutputStream方法:

举例FileInputStream,FileOutputStream:

public class test{
    public static void main(String[] args)throws IOException{
        FileInputStream FI=new FileInputStream("C:\\Users\\a\\Desktop\\java复习\\zma.txt");
        byte[] buffer=new byte[520];
        int count=FI.read(buffer);//从文件中读入到缓冲区
        for(byte b:buffer){
            System.out.print((char)b);
        }
        FileOutputStream FO=new FileOutputStream("C:\\Users\\a\\Desktop\\java复习\\yyq.txt",true);
        //若文件不存在，构造文件输出流对象时会自动创建一个文件
        //写入文件时，有两种方式，一种是覆盖，一种是追加(append为true)

        FO.write(buffer,0,count); //将字符数组中的数据写入缓冲区
        FO.flush();//刷新缓冲区
        FI.close();
        FO.close();

PipedInputStream和PipedOutputStream
通常用于将一个程序的输出连接到另一个程序的输入。

5.3字符流

字节流与字符流之间的转化
输入字节流转为字符流需要用到inputstreamReader的构造方法，输出字符流转为字节流用到OutputStreamWriter或PrintWriter的构造方法
流的装配:
过滤流Buffered-InputStream和BufferedOutputStream，缓存作用，用于装配文件磁盘、网络设备、终端等读写开销大的节点流，提高读写性能
过滤流BufferedReader的使用：用于缓存字符流，可以一行一行的读
数据流DataInputStream和DataOutputStream，可从字节流中写入、读取Java基本数据类型，不依赖于机器的具体数据类型，方便存储和恢复数据
PrintWriter的使用：可以向该字符流中写入Java基本数据类型，用于包装输出字符流类对象
对象序列化:
序列化(Serialization)：将实现了Serializable接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象，后者又称反序列化。

6 线程

6.1 线程的概念与创建

一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源，每一个进程的内部数据和状态都是完全独立的。Java程序执行中的单个顺序的流控制称为线程，多线程则指一个进程中可以同时运行多个不同的线程，执行不同的任务。
产生线程有两种方法:一种是通过继承Thread类，覆写run方法，另一种就是实现Runnable接口，并将实现类对象作为参数传递给Thread类的构造方法
在这里插入图片描述

6.2 线程的控制与调度

在这里插入图片描述
Join()方法可以使main()线程暂时停止运行，直到该线程完成后继续执行。
线程调度与优先级:
当有多个线程处于Runnable状态时，线程调度程序根据调度策略安排线程的执行：
调度策略：
• 抢占式调度(preemptive): 支持基于固定优先级的调度算法，高优先级线程抢占低优先级线程执行;
• 时间片轮转调度(round-robin)：对于同等优先级的线程，轮流分享CPU时间运行
线程优先级：
public static final int NORM_PRIORITY = 5;
public static final int MIN_PRIORITY = 1;
public static final int MAX_PRIORITY = 10;
设置线程的优先级:
public final void setPriority(int newPriority);
返回线程的优先级:
public final int getPriority();
Java中，优先级高的线程只是比优先级低的线程更有机会执行，具体的执行情况还依赖于操作系统的支持，执行顺序并不是确定的
6.3 线程的同步机制(互斥)
多个线程想要对某个对象进行并发更新操作，竞争共享资源，可能会产生不正确的结果。

volatile：禁用CPU缓存 (可见性问题)
可见性：一个线程对共享变量的修改对其他线程都是可见的。
volatile修饰的变量：对此变量的操作都会在内存中进行，不会产生副本，以保证共享变量的可见性。
原子性：不可分割的一系列操作指令
解决：同步机制以保证操作的原子性实现互斥
同步机制:
1. 对象监视器（monitor）与synchronized
Synchronized的三种用法：
synchronized 代码块：监视器就是指定的对象。
synchronized 方法：监视器就是this对象。
synchronized 静态方法：监视器就是相应的Class对象。
2. Java并发包中的锁类
Lock接口
ReentrantLock类
private final ReentrantLock lock = new ReentrantLock();
lock.lock();
lock.unlock();

7 集合框架

集合框架由一系列的集合类和接口所组成，主要存放于java.util包中。集合接口提供对集合元素的共性操作，如增删查改集合元素。集合类封装了底层常用的数据结构，开发者无需知晓底层具体的实现就可以方便的操作集合元素。
Collection是集合类的基本接口，它用来说明作为一个集合类应有的结构特征属性和带有共性的操作方法。

7.1 常用集合类

ArrayList类
ArrayList --使用泛型内部实现基于数组
LinkedList类（内部实现基于链表）
ArrayDeque （提供栈结构实现）
HashSet （无重复元素的集合）
对集合类遍历的接口
在这里插入图片描述

ListIterator接口—不仅可以实现向后遍历，还可以实现向前遍历
HashSet实现基于HashMap（哈希表）
通过hashCode和equals方法确保集合元素的唯一性。
1如果两个对象的equals的结果是相等的，则两个对象的hashCode的返回结果也必须是相同的。
2 任何时候覆写equals，都必须同时覆写hashCode。
Hashcode方法是对对象存储地址的一个映射（object类），在判断key是否存在时首先进行hashcode的判断，若不覆写hashcode则两个对象必定地址不同，就不会进行后面的覆写的equals方法的比较。

7.2 集合对象排序

7.2.1接口Comparable（自身比较器）

Integer、String等类已经实现了Comparable接口
抽象方compareTo(T o)

class Person implements Comparable<Person>{
    String sno;
    String name;
    int age;
    Person(String sno,String name,int age){
        this.sno=sno;
        this.name=name;
        this.age=age;
    }
    @Override
    public int compareTo(Person p1){
        return this.age<this.age?1:-1;
    }
    @Override
    public String toString(){
        return "sno:"+sno+" name:"+name+" age:"+age;
    }
}
public class test{
    public static void main(String[] args)throws IOException{
        ArrayList<Person> arr=new ArrayList<Person>();
        arr.add(new Person("1","zma",19));
        arr.add(new Person("2","yyq",18));
        arr.add(new Person("3","zz",20));
        Collections.sort(arr);
        for(Person p:arr){
            System.out.println(p);
        }
    }
}

7.2.2集合对象排序接口Comparator（自定义比较器）

public class test{
    public static void main(String[] args)throws IOException{
        ArrayList<Integer> arrayList = new ArrayList<Integer>();
        arrayList.add(123);
        arrayList.add(224);
        arrayList.add(45);
        Collections.sort(arrayList,new cmp());
        System.out.println(arrayList);
    }
}
class cmp implements Comparator<Integer>{
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1>o2?-1:1;
    }
}

7.3 Map

Map接口用于将一个键(Key)映射到一个值(Value),且不允许有重复的键，每个键最多映射到一个值。
Map的实现类有Hashtable（已淘汰）, HashMap, TreeMap
Map的遍历:
按Entry集合来遍历
for each语句

public class test{
    public static void main(String[] args)throws IOException{
        HashMap<String,String>map=new HashMap<String,String>();
        map.put("zma","19");
        map.put("yyq", "20");
        Set<HashMap.Entry<String, String>> entries =map.entrySet();
        for(HashMap.Entry<String,String> m:entries){
            System.out.println(m.getKey()+":"+m.getValue());
        }
    }
}

按Key集合来遍历
for each语句

public static void main(String[] args)throws IOException{
        HashMap<String,String>map=new HashMap<String,String>();
        map.put("zma","19");
        map.put("yyq", "20");
        Set<String>keys=map.keySet();
        for(String s:keys){
            System.out.println(s+":"+map.get(s));
        }
    }

7.3.1 HashMap原理

HashMap内部实现基于哈希表，采用链表法解决哈希冲突
HashMap初始化和动态扩容（减少哈希冲突）
Java8的对哈希表中链表过长的优化，当链表长度大于等于8时，链表会转换为红黑树，以提高性能
HashMap是非线程安全的，多线程环境下应使用ConcurrentHashMap。
当使用自定义对象作为Key时，需同时覆写hashCode和equals方法，以确保Key的唯一性。(参见HashSet示例)

7.3.2 TreeMap原理

TreeMap内部实现基于红黑树（属于二叉查找树）。
TreeMap按照Key的排序结果来组织内部结构
TreeMap依靠Comparable和Comparator实现Key的去重。
TreeMap和HashMap

==Collection是集合类的基本接口，它用来说明作为一个集合类应有的结构特征属性和带有共性的操作方法.
Collections类该类通过一些静态方法，完成集合类的一些操作功能，例如Collections.sort(List l);
注意：Collections和Collection是两个不同的概念，前者是类，后者是集合接口 ==

8 JDBC

JDBC是Java面向对象应用程序访问数据库的接口（API）规范,它的出现使Java应用程序对各种关系数据库的访问方法得到统一
java.sql包定义了访问数据库的接口和类

9 网络通信

9.1从URL读取WWW网络资源

当得到一个URL对象后，就可以通过它的方法openStream()读取指定的WWW资源。这个方法与URL代表的服务资源建立连接并返回InputStream类的对象，进而读取数据。

public class test{
    public static void main(String[] args)throws IOException{
        URL tric=  new URL("http://coi.hzau.edu.cn/");
        BufferedReader in=new BufferedReader(new InputStreamReader(tric.openStream(),"UTF-8"));
        String line;
        while((line=in.readLine())!=null){
            System.out.println(line);
        }
        in.close();
    }
}

9.2基于Socket套接字的低层次Java网络编程

两类传输协议：TCP和UDP
Socket是TCP/IP协议的一个十分流行的编程接口，一个Socket由一个IP地址和一个端口号唯一确定
TCP是一种面向连接的保证可靠传输的协议，传输数据前先要建立连接！
Socket, ServerSocket
accept()方法：一直阻塞，直到连接请求到来，并接收该连接，返回一个新的Socket对象

9.3基于数据报的低层次Java网络编程

UDP协议-DatagramSocket与DatagramPacket
DatagramSocket：用于发送或接收数据报，是数据报投递服务的一个发送或接收点。
DatagramPacket：用来表示一个数据报。
TCP与UDP的比较
在这里插入图片描述

StarryTank

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java复习总结

1 面向对象(1)在判断访问权限时，要首先判断类的权限，再判断数据成员，方法的权限。Java程序分为Application和Applet，首先都通过javac命令编译成字节码文件，Application通过java解释器执行Java字节码文件，独立运行，Applet不能独立运行，需要依赖浏览器，用appletviewer工具来调试。数组的长度：arr.length字符串的长度 str.length()toString方法返回该对象的字符串，便于输出public class test{publi
复制链接

扫一扫