java笔记

第一章

Java编译器：javac 将源程序(.java)编译生成字节码(.class)

Java解释器：java 将字节代码在机器上解释执行

垃圾收集在Java程序运行过程中自动进行，程序 员无法精确控制

每个单元可以由： 最多有一条package语句； 任意条import语句； 至少有一个类class声明或接口interface声明构成，public类仅一个

main签名：public static void main(String args[])

args不包含执行文件路径

Java程序的运行需要经过编写、编译、运行三个步骤

第二章

import语句在包语句后，所有类或接口之前。 import语句有两种形式： 1：import 包名.类名; 2：import 包名.*;

在Java语言中，标识符取名的规则： Ø 必须由字母、下划线或美元符开头的； Ø 并由字母、数字、下划线和美元符组成的； Ø 不能与关键字同名

引用类型(数组、class或interface)声明变量时，是不会 为变量(即对象)分配存储空间。它们声明的变量不是数 据本身，而是数据的引用(reference)，需用new运算符 来为引用类型的变量分配贮存空间。new一定会创建新的对象。

Ø 十进制整数是由不以0开头，0～9数字组成数据：12； Ø 八进制整数是由以0开头，0～7数字组成的数据：012； Ø 十六进制整数是由以0x或0X开头，0～9数字及A～F的字 母组成的数据：0x12AB。  整型数常量均为int类型，除非在其后有字母“L” 来表示是长整型long的值

在数值后面不带有任何大小写字母f或d时，表示为double

opBt1 >> opBt2 opBt1右移opBt2位

opBt1 >>> opBt2 opBt1无符号右移opBt2

char:utf16

byte, short, char→int → long → float → double

<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2

第三章

break语句也可以带语句标记，它的作用是结束 该语句标记的语句块

continue语句也可以带语句标记，它的作用是结 束该语句标记的外层循环的本次循环。

数组是一个对象，数组声明不能创建对象本身， 而创建一个引用。数组元素由new语句或数组 初始化软件动态分配

必须首先将低位维初始化，才能对它后面的各 维依次初始化，可以创建非矩 形数组的数组。

对字符串数据与其它类型数据使 用“+”运算符连接操作编译时，总是首先将其 它类型数据转换为字符串类型，然后再进行字 符串连接。运算从左至右

Java在一般 对象的基础上进行了优化，将所有的字符串放在了 常量池，当常量池中已有该字符串时则不再新建， 这里没有说明现有常量池中是否有xyz字符串。因 此本题的答案时，如果常量池中没有xyz字符串， 则创建两个StringObject，如果常量池中已有 xyz字符串，则创建一个StringObject

String s=new String(“xyz”) 由双引号创建字符串常量，可能合并，new创建string对象，不可合并

String a="123";
String b="123";
System.out.print(a==b);
//true

string静态不能加快连接操作，（若不存在）会在常量池创建新的字符串

未初始化string值为null

Double不合并，Integer小整数缓存

第四章

在面向对象编程中，继承、多态、封装和抽象是四个基本特性。

成员变量初始化分两种：

创建的变量时初始化值。 例： int a, b; //成员变量a和b都有一个初始值为0。

创建时赋初值； 例： int x = 10, y = 20; //x,y分别赋初值10,20。

在类的构造器中对成员变量的赋初值。 例：Point(){ x = 10; //x赋初值10 y = 20; //y赋初值20 }

使用修饰符final修饰的变量就像常量一样地使用， 称其为常量符号。

常量符号数据只能读取，不能改变。通常常量符号 标识符全用大写字母，单词间用“_”分隔

final在定义时初始化或在构造器中初始化

方法在被调用时，其参数的数据传递是值传递，即实际参数传值给形式参数。对象的值为其地址

由于static 方法不需要创建任何对象，所以它 们不可简单地调用其他那些成员（ static方法 只能访问static成员变量和static方法）

对类对象调用static方法相当于对类调用static方法

第五章

在超类中，由private修饰的访问权限的成员变量 和方法，虽然被子类继承，但是子类不能访问。

子类重写父类的方法（签名相同），权限不能缩小

超类的一个对象（变量）可以被任何从该超类 派生的子类的引用赋值（引用（指向）子类的 实例）。

 超类对象（变量）不能访问子类新定义的成员 （变量、方法）

 超类对象（变量）引用子类实例，则可以通过 强制转换为子类引用

在子类的创建中，如果出现了与其超类相同的 成员变量，则超类中的成员变量被子类中的成员 变量所隐藏

在子类的创建中，如果出现与超类中有相同名、同参数及同返回类型的成员方法(含static)，则超类中 的成员方法被子类中的成员方法所覆盖。

子类强制转化为父类时，父类成员变量重新表现，而成员方法(非static)及在方法中引用的成员变量被子类重写

父类的static方法不会被覆盖，子类对象转化为父类时会重新表现

父类转换为子类会产生_运行时错误_

this 表示对类的实例访问，它也表示了对象对该实例引用访问。；  在类中可以来指向成员变量，以示区别于非成员变量

super 在子类中，使用super访问被隐藏的超类变量，被覆盖 的超类方法

class ClassA{
void callMe(){
System.out.println("在ClassA中的callMe()方法!"); } }
class ClassB extends ClassA{
void callMe(){
System.out.println("在ClassB中的callMe()方法!"); } }
public class TestConvert{
public static void main(String arg[]){
ClassA vA = new ClassB();
vA.callMe(); } }

程序运行输出的是： 在ClassB中的callMe()方法！ 结果说明了vA调用callMe()是子类ClassB中的方法。

class First{
First(){ aMethod(); bMethod();}
public void aMethod(){ System.out.println(“in First class”);}
public void bMethod(){ System.out.println("in First class b 
method"); }}
public class Second extends First{
Second(){ aMethod(); }
public void aMethod(){ System.out.println(“in Second class”);}
public static void main(String[ ] args){ new Second( ); }}

in Second class in First class b method in Second class

子类构造时，会先调用父类无参数构造器，但构造器与其他成员方法间动态链接，父类构造器可能调用子类重写的成员方法

父类必须具有无参数构造器，否则编译错误

没有重写过的equals()方法和==是一样的，都是比较两个对象引用指向的内存地址是否一 样判断两个对象是否相等，但可以通过重写equals()方法实现依据对象的值来判定是否相等， Java中很多类都自身重写了equals()方法。类似地，要使自定义的对象能正确比较，

第六章

在通用引入和具体引入并存时，使用声明更具体的 包中的类

在都是具体引入并存时，后一个语法错误或使用第 一个具体指明包中的类

在都采用通配符引入时，必须选择正常才能使用

接口中的所有方法都是abstract方法， 这些方法是没有语句

接口默认public，需要被重写

关键字implements不同于extends，它表示类对 接口的实现而不是继承，并且一个类可以实现多个 接口。类实现接口，则必须实现接口中的所有方法

内部类可以调用外部类的成员方法和变量，内部类不能声明static变量和方法

匿名类使用一个类的子类的类体创建对象,只用一次，无构造器，继承父类或实现接口

people a=new people(){
	//ababab
};

{}内实现people的子类

可用于访问不同包非子类protect方法、变量

第七章

catch从上到下匹配，若范围小的exception在范围大的exception之下，则会编译时错误。catch子类在前、父类在后。

finally在try/catch后执行，但永远都会在catch/try的return或异常前被执行。catch/try的return结果会被缓存，然后执行finally，如果finally中没有return或异常，则会返回被缓存的结果

throws声明方法可能抛出异常，向上传递

子类重写父类的方法，只能抛出父类能抛出的异常

用户自定义异常是exception子类

throwable有error和exception两个子类

JVM自动处理runtime exception

第八章

节点流：特定位置读写，其余过滤器（中间处理）

File类的主要方法：

1. 文件路径和属性  getPath()和getAbsolutePath()方法返回File对象的路径和绝对路径。  getName()方法返回File对象的文件名或目录名。  getParent()返回File对象的父目录。  表示文件的属性或状态： File f = new File(”demo.txt”); f.getName()：获得文件名demo.txt f.exist()：文件demo.txt存在返回true。 canWrite()，canRead()，isDirectory()，isAbsolute()，exist()，isFile() 都返回boolean型数据，分别表示文件是否写保护，是否读保护，是 目录还是文件，是否使用绝对路径，是否存在
2. 创建目录和删除文件  mkdir()和mkdirs()用于创建目录。创建目录的位置完全取决于File对 象的路径。  delete()用于删除文件或目录，删除目录时，应该保证所删目录是一 个空目录，否则删除操作失败。 3. 文件更名  renameTo()方法不但可以给文件更名，而且可以给目录更名。  equals()判断两个File对象是否相等，程序用它来判断用户给定的原文 件名和新文件名是否相等，如果相等则不能进行更名操作。
3. list()方法产生目录清单，它只返回指定目录中包 含的文件名或子目录名，没有文件长度、修改时 间、文件属性等信息。 lastModified()返回文件最后一次被修改的时间， 其值是相对于1970年1月1日的时间毫秒数，为便 于阅读，必须变成java.util.Date对象

RandomAccessFile，随机读写，由string、file与读写模式构造，写入覆盖原文件对应部分，其他部分不变readInt，writeByte，etc seek移动指针，getFIlePoint。数据类型Byte，Short，Int，Long，Float，Double，Char，Boolean的读写分别在read和write方法作后缀。例：readInt()：读一个int数。writeInt()：写一个int数。

inputstream抽象类，available剩余字节数；skip跳过一定数量；mark(int)标记位置，reset()回到标记位置。

 int read() 方法返回一个0至255之间的整数或-1, -1代表遇到了流的结束，其 它对应读入的字节  int read(byte[]) 方法则将字节读入参数给定的字节数组，返回值是实际读入的字 节数或-1(遇到了流结束)  int read(byte[],int,int) 方法的后两个参数分别给出读入的起始位置和读入的最大字节数

outputstream，flush强制输出缓存

int write (int) 向流的末尾写入一个字节的数据 int write (byte[]) 将数组b中的数据依次写入当前的流对象中 int write (byte[],int,int) 将数组中从开始下标(包含)，后续长度的数据依次 写入到流对象中

FileOutputStream支持覆盖、追加

buffered缓冲，由stream初始化，可指定缓冲区大小

Data：readInt，writeByte，etc

sequence：将几个stream连接，忽略中间的EOF

reader、writer字符单位抽象类

inputstreamreader、outputstreamwriter自动转换Unicode

bufferedreader、bufferedwriter

pipedinputstream/pipedoutputstream进程线程间通信，input由output构造，output由input构造

1.2 常见的 I/O 类

• 字节流类：

  • FileInputStream 和 FileOutputStream：用于字节流读取和写入文件。

    FileOutputStream(String) FileOutputStream(String,boolean附加为true) FileOutputStream(File) FileOutputStream(FileDescriptor

  • BufferedInputStream 和 BufferedOutputStream：为字节流提供缓冲功能，提高读写性能。

• 字符流类：

  • FileReader 和 FileWriter：用于字符流读取和写入文件。
  • BufferedReader 和 BufferedWriter：为字符流提供缓冲功能，提高性能。

• 数据流类：DataInputStream 和 DataOutputStream：用于读写原始数据类型（如 int、double 等），确保跨平台兼容性。

• 对象流类：ObjectInputStream 和 ObjectOutputStream：用于读写 Java 对象（需要对象实现 Serializable 接口）。

2. 文件的基本读写操作

2.1 读取文件

使用字节流和字符流可以进行文件的读取操作。

2.1.1 使用 FileInputStream 读取文件（字节流）

import java.io.FileInputStream;
import java.io.IOException;

public class FileReaderExample {
    public static void main(String[] args) {
        String filePath = "example.txt";
        try (FileInputStream fileInputStream = new FileInputStream(filePath)) {
            int byteData;
            while ((byteData = fileInputStream.read()) != -1) {
                // 读取文件内容并输出
                System.out.print((char) byteData);  
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.1.2 使用 FileReader 读取文件（字符流）

import java.io.FileReader;
import java.io.BufferedReader;
import java.io.IOException;

public class FileReaderCharExample {
    public static void main(String[] args) {
        String filePath = "example.txt";
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                // 输出每一行
                System.out.println(line);  
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2 写入文件

2.2.1 使用 FileOutputStream 写入文件（字节流）

import java.io.FileOutputStream;
import java.io.IOException;

public class FileWriterExample {
    public static void main(String[] args) {
        String content = "Hello, Java File I/O!";
        try (FileOutputStream fileOutputStream = new FileOutputStream("output.txt")) {
            // 写入字节数据
            fileOutputStream.write(content.getBytes());  
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.2.2 使用 FileWriter 写入文件（字符流）

import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.IOException;

public class FileWriterCharExample {
    public static void main(String[] args) {
        String content = "Hello, Java File I/O!";
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            // 写入字符串
            writer.write(content);  
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) {
 Worm w=new Worm(6,'a');
 System.out.println("w="+w);
 try{
 ObjectOutputStream out=new ObjectOutputStream(new 
FileOutputStream("worm.out"));
 out.writeObject("Worm storage");
 out.writeObject(w);
 out.close();
 ObjectInputStream in =new ObjectInputStream(new 
FileInputStream("worm.out"));
 String s=(String)in.readObject();
 Worm w2=(Worm)in.readObject();
 System.out.println(s+",w2="+w2);
 }catch(Exception e){
 e.printStackTrace();       
}}

 PipedOutputStream producer = new PipedOutputStream();
 PipedInputStream consumer = new PipedInputStream(producer);
 out.writeDouble(num);

import java.io.*;
public class Find {
    public static void main(String args[]) {
        BufferedReader bRead = null;
        BufferedWriter bWrite = null;
        String buffer;
        boolean outFile = false;
        int i = 0;
        try {
            FileReader fr = new FileReader(new File(args[0]));
            bRead = new BufferedReader(fr);
        } catch (IOException e) {}
            try {
                FileWriter fw = new FileWriter(new File(args[2]));
                bWrite = new BufferedWriter(fw);
                outFile = true;
            } catch (IOException e) {}
        try {
            buffer = bRead.readLine();
            while (buffer != null) {
                if (buffer.indexOf(args[1]) != -1) {
                    if (outFile) {
                        bWrite.write(buffer);
                        bWrite.newLine();
                    }
                    System.out.println(buffer);
                    i++;
                }
                buffer = bRead.readLine();
            }
        } catch (IOException e) {
        } finally {
            try {
                bRead.close();
                if (bWrite != null) bWrite.close();
            } catch (Exception e) {}}}}