—> 把这几百页的书从头到尾看一遍梳理一下期末考点吧！

基本数据类型与数组

标识符和关键字

  1. 字母、下划线、美元符号、和数字
  2. 第一个不能是数字
  3. 不能是关键字
  4. 不能是true false null（尽管他们不是关键字）
  5. 区分大小写

基本数据类型

8种基本数据类型

boolean

byte,short,int,long

char

float,double

  1. int 四字节
  2. byte一个字节
  3. short两个字节
  4. long八个字节
  5. 没有无符号即unsigned
  6. char两个字节，没有负数
  7. 使用unicode字符集，前128个是ASCII
  8. ‘\u0041’表示A
  9. （char)65 a
  10. double y = 0.4 小于 float x = 0.4f;

类型转换运算

低赋值给高会自动转换，反之需要强制转换

低到高排序：byte short char int long float double

int x = (int)34.89

float x = 12.3 这是错误的，默认浮点数常量是double，如果不转换会报错“possible loss of precision”

输入输出数据

输入

Scanner reader = new Scanner(System.in);

reader调用以下方法，返回值就是读取的内容：

nextBoolean() nextByte() nextShort() nextInt() nextLong() nextFloat() nextDouble()

输出

System.out.println() System.out.print() System.out.printf()

Syetem.out.println("hhh
                   hhh
                   hhh"); /这样是不正确的，不允许出现回车，print也是。可以通过加号连接
Sout("hh"+
    "hhh");

printf用法类似C

System.out.printf("%d %f",12,1,3);

数组

int arr[] int[] arr

int arr[][] int[][] arr

和c不同，这里只是生命数据类型，而不能定义其中多少个元素，所以必须

int arr[] = new int[10];

当然也可以分步

  1. arr.length可以获取数组长度
  2. 二维数组中的每行长度可以不相同
  3. sout输出数组会输出引用地址，而对于char数组会输出内容，可以用过""+arr来输出引用

运算符、表达式和语句

运算符与表达式

  1. && || !
  2. =左边必须是变量
  3. 位运算符
    1. &
    2. |
    3. ~(单目)
    4. ^
  4. instanceof（左边是对象，右边是类，返回值是true false

语句

  1. 分号是空语句

  2. for与数组

    for(int i : arr)
    {
        System.out.println(i);
    }

  3. 应用（连续读入）

    while(reader.hasNextDouble())
    {
        double x=  reader.nextDouble();
    }

类和对象

  1. 包名第一部分不能是“java”

  2. 创建类不加public即默认为friend，不能使用protected和private

  3. 基本类型的类封装

    Double Float Byte Short Integer Long Character

    通过调用如intValue() shortValue()来获取基本类型值

    可以调用这些类的一些方法例如

    Character.toUpperCase() Character.isLowerCase()

子类与继承

  1. 不持支多继承

    class Child extends Parent{
        ...
    }

  2. 继承不会继承private，而且当不在一个包的时候也不会继承friend

  3. 尽管如private的变量不会被继承，但依然在创建对象的时候会分配内存，因为有可能会用方法调用这些变量

  4. instanceof 如果左边的是右边或是右边子类创建的话就是true

  5. 重写（override）以后，想要调用父类的变量或者方法需要super

  6. 重写不允许降低访问权限但是可以提高

  7. 子类构造方法中如果明确调用哪一个父类的构造方法的话，就会调用Parent()这个无参的方法，但如果用super指出，就必须是子类构造方法中的第一句。

  8. final修饰一个类，则该类不可以被继承

  9. final修饰一个方法，则该方法不可以被重写

  10. final修饰变量，则成为常量

  11. 上转型对象会失去一些子类的属性和方法，按时上转型对象会调用子类重写的（非静态）方法（多态….）

  12. 上转型对象可以再强制转化为子类对象

  13. abstract所在的类必须是abstract类

  14. 抽象类不可以被new，必须被继承重写abstract方法

接口与实现

  1. 接口包括常量（final）和抽象方法。
  2. 变量默认必须是 public final static ，所以可以省略
  3. 抽象方法可以省略（putlic abstrac）
  4. 实现接口implements xxx,xxx,xxx
  5. 必须重写所有方法，且必须用public修饰
  6. 接口回调，有点类似于向上转型吧（也就是接口的多态）
  7. 如果接口作为参数，那么可以将实现该接口的类的实例传进去

内部类和异常类

所谓内部类就是在一个class里面再定义一个class，可以通过xxx.xxx来访问这个class

  1. 内部类可以用static修饰
  2. 异常类

常用实用类

String

  1. 创建 String s = new String("hhhh")
  2. 还可以传入字符数组
  3. 可以引用常量String s1,s2; s1 = "hhh";s2 = "ggg";s1 == s2(true);
  4. 字符串的并置，当两个常量并置时，得到的是在常量池，如果有变量则新生成变量
  5. 常用方法：length() equals(String s) startsWith() endsWith() compareTo()大正小负 contains() indexOf() lastIndexOf() subString( int start, int end ) trim()
  6. 字符串与基本数据的转化Integer.parseInt(s)其他类似
  7. String类不可以有子类
  8. 符串与基本数据的相互转化
    1. public static int parseInt(String s)
    2. String str = String.valueOf(12313.9876);
  9. 字符串与字符数组
    1. void getChars()
    2. char[] toCharArray()
  10. 正则，主要是matches和replaceAll以及split，返回值分别是boolean String String[]

StringTokenizer

StringTokenizer = 呢哇StringTokenizer("you are welcome");
StringTokenizer = 呢哇StringTokenizer("you##are#*#welcome","#*");//分隔符时#*的任意排列

//方法
hasMoreTokens();
nextToken();
countTokens();

Scanner

  1. 默认将字符串按照空格分隔，调用next()或者nextInt()等方法一个一个返回，知道hasNext()返回false

    String NBA = "I Love This Game";
    Scanner scanner = new Scanner(NBA);

  2. 使用正则表达式作为分隔标记解析字符串

    Scanner sc = new Scanner("hh 12 hh 24 hh");
    sc.usDelimiter("[^0123456789.]+");//设置分隔符

  3. 传入File对象，通过next()和nextLine()获取输入

    1. next():
      • 一定要读取到有效字符后才可以结束输入。
      • 对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
      • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
      • next() 不能得到带有空格的字符串。
    2. nextLine()：
      • 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
      • 可以获得空白。
    3. 如果要输入 int 或 float 类型的数据，在 Scanner 类中也有支持，但是在输入之前最好先使用 hasNextXxx() 方法进行验证，再使用 nextXxx() 来读取

StringBuffer()

StringBuffer是可更改的，append()追加

public char charAt(int n);
public void setCharAt(int n, char ch);
StringBuffer insert(int index, String str);
reverse
delete
replace

Date

Date time = new Date();
print(time);
Date time = new Date(1000);

数字格式化

String s = String.format("%.2f",3.1415);
//以下为修饰符
%d;
%o;
%x;
%X;
%+d;
%,d;
%-8d;
%f(6位);
%e(%E)科学计数法;

输入、输出流

文件

流

FileInputStream、FileOutputSteam

FileReader、FileWriter

BufferedReader、BufferedWriter

对于缓冲流：

  1. 构造方法

    BufferedReader(Reader in);
    BufferedWriter(Writer out);

  2. 方法

    FileReader inOne = new FileReader("student.txt");
    BufferedReader inTwo = BufferedReader(inOne);

    String strLine = inTwo.readLine();

    FileWriter tofile = new FileWriter("hello.txt");
    BufferedWriter out = BufferedWriter(tofile);

    out.write(str);
    out.newLine();

  3. 注意要先关闭缓冲流，再关闭输入输出

多线程

  1. 创建

    1. extends Thread，然后重写run方法
    2. new Thread（Runnable target），构造函数的参数是implement Runnable的实例，该实例也需要重写run方法

  2. 运行

    start()

  3. 常用方法

    sleep(int millsecond)

    isAlive()

    currentThread()

  4. 目标对象和线程间的关系（完全解耦和弱耦合）

  5. 线程同步

    用synchronized修饰的方法必须遵守同步机制，即当一个线程正在使用时，其他线程若要使用则必须等待

  6. 协调同步

    wait()来中断当前线程
    notifyAll()通知中断的线程继续执行，先中断先继续

  7. Timer
    该类在javax.swing
    我太困了……..-_-……..

泛型与集合框架

泛型

class Cone<E> {
    double height;
    E bottom;
    Publi Cone ( E b ){
        bottom = b;
    }
}

Cone<Circle> coneOne;
coneOne = new Cone<Circle> (new Circle());

链表

LinkedList<String> mylist = new LinkedList<String>();

//常用方法
public boolean add(E element) //向链表末尾添加一个新的节点，该节点中的数据是参数elememt指定的数据。
public void add(int index ,E element) //向链表的指定位置添加一个新的节点，该节点中的数据是参数elememt指定的数据。
public void clear() //删除链表的所有节点，使当前链表成为空链表。
public E remove(int index) //删除指定位置上的节点。
public boolean remove(E element) //删除首次出现含有数据elemen的节点。
public E get(int index) //得到链表中指定位置处节点中的数据。
public static sort(List<E> list) //升序
//◆ LinkedList<E>泛型类本身新增加的一些常用方法 
public void addFirst(E element) //向链表的头添加新节点，该节点中的数据是参数elememt指定的数据。
public void addLast(E element) //向链表的末尾添加新节点，该节点中的数据是参数elememt指定的数据。
public E getFirst() //得到链表中第一个节点中的数据。
public E getLast() //得到链表中最后一个节点中的数据。
public E removeFirst() //删除第一个节点，并返回这个节点中的数据。

遍历

LinkedList<String> mylist = new LinkedList<String>();
Iterator<String> it = mylist.iterator();
while(it.hasNext())
{
    print(it.next());
}

哈希表

HashMap<String,Student> hashtable = HashSet<String,Student>();
//常用方法
public V put(K key,V value)//将键/值对数据存放到散列映射中，该方法同时返回键所对应的值。 
public void clear() //清空散列映射。
public Object clone()  //返回当前散列映射的一个克隆。
public boolean containsKey(Object key) //如果散列映射有“键/值”对使用了参数指定的键，方法返回true，否则返回false。 
public boolean containsValue(Object value) //如果散列映射有“键/值”对的值是参数指定的值。
public V get(Object key) //返回散列映射中使用key做键的“键/值”对中的值。
public boolean isEmpty()  //如果散列映射不含任何“键/值”对，方法返回true，否则返回false。
public V remove(Object key) //删除散列映射中键为参数指定的“键/值”对，并返回键对应的值。
public int size() //返回散列映射的大小，即散列映射中“键/值”对的数目。