记录学习java语法的过程，学习总结

java构造器

java中的类构造器，相当于java中的__init__初始化方法，当你在创建类对象的时候，就会默认先执行java构造器,无需再调用，构造器中的变量可通过对象调用：

public class test {
    String name;

    // java构造器
    public test(String name){
        this.name= name;
    }

    private static int age(int num){
        int ages;
        ages = num;
        return ages;
    }

    public void outprint (){
        // write your code here

        test c = new test("yu");
        System.out.println(c.name);
        System.out.println(c.age(789));
    }

    public static void RegexMatches(){
        // 正则
        String REGEX = "\\bcat\\b";
        String INPUT = "cat cat cat cattie cat";

        Pattern p = Pattern.compile(REGEX);
        Matcher m = p.matcher(INPUT); // 获取 matcher 对象
        int count = 0;

        while(m.find()) {
            count++;
            System.out.println("Match number "+count);
            System.out.println("start(): "+m.start());
            System.out.println("end(): "+m.end());
        }

    }
}

java重载方法

java的重载还是很神奇，重载是方法名相同，类型不同，怎么区分要调用那个方法呢？java使用数据类型来区分调用那个方法。

public class chongzai {
    // java重载方法
    public static int data(int num){
        System.out.println("你调用的是int:");
        return num;
    }

    public static double data(double num){
        System.out.println("你条用的是double");
        return num;
    }

    public static void main(String[] args) {
        int a = data(4);
        double c = data(4.5);
        System.out.println(a);
        System.out.println(c);
    }
}

java命令行参数

在命令行启动java程序的时候，如果需要让程序接受参数，就需要进行传参给程序main函数,用args接受参数，可以接收多个参数，因为args是一个列表

IO操作控制台

public class BRReadLines {
    public static void main(String[] args) throws IOException{
        // 读取控制台输入的字符串
        BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
        String str;
        do {
            str = rd.readLine();
            System.out.println(str);
        }while (!str.equals("end"));

    }
}

java读写文件方法，FileInputStream和FileOutputStream

FileInputStream用来读取文件数据，使用new来创建对象有多种构造方法可用来创建对象。可以使用字符串类型的文件名来创建一个输入流对象来读取文件：


public class fileStreamTest2 {

    public static void main(String[] args) throws IOException{
        read();
        wirte();

    }
    private static void read() throws IOException{
        // 写入路径
        File f = new File("/home/derek/IdeaProjects/two/src/data/3.txt");
        // 构建FileOutputStream对象,文件不存在会自动新建
        FileOutputStream fop = new FileOutputStream(f);
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
        OutputStreamWriter writer = new OutputStreamWriter(fop,"utf8");
        // 写入到缓冲区
        writer.append("中文输入");
        
         //换行
        writer.append("\r\n");
       
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
        writer.append("English");
        
        //关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
        writer.close();
        
        // 关闭输出流,释放系统资源
        fop.close();
        

    }
    private static void wirte() throws IOException{
        // 读取文件路径
        File f = new File("/home/derek/IdeaProjects/two/src/data/3.txt");
        // 构建FileInputStream对象
        FileInputStream fip = new FileInputStream(f);
        // 构建InputStreamReader对象,编码与写入相同
        InputStreamReader reader = new InputStreamReader(fip,"utf8");
        // 拼接字符
        StringBuffer sb = new StringBuffer();
        while (reader.ready()){
            sb.append((char) reader.read());
        }
        System.out.println(sb.toString());

        reader.close();
        fip.close();
    }

}

java继承

java继承可以使用 extends 和 implements 这两个关键字来实现继承在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

Java 重写(Override)与重载(Overload)

java重写和python类似
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

方法的重写规则

参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

被重载的方法必须改变参数列表(参数个数或类型不一样)；被重载的方法可以改变返回类型；被重载的方法可以改变访问修饰符；被重载的方法可以声明新的或更广的检查异常；方法能够在同一个类中或者在一个子类中被重载。无法以返回值类型作为重载函数的区分标准。

java多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作

java多态实现方法：

实现方法1：
重写
实现方法2：
接口
实现方法3：
抽象类和对象

java抽象类

java抽象类，不能实例化对象，可以被继承;所以要使用抽象类，就需要被一个类继承，而这个类只能继承一个抽象类; 在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口
在Java语言中使用abstract class来定义抽象类 ;在使用extends继承抽象类; 抽象类中的方法，不一定是抽象方;但是抽象方法一定在抽象类中

声明抽象方法会造成以下两个结果：

如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

在继承类中如果要使用,需要重写父类抽象方法

java接口　　

接口通常以interface来声明　　

接口与类的相识处：　　

接口可以有多个方法
接口保存在．.java结尾的文件中，文件名使用接口名
接口的字节码文件保存在 .class 结尾的文件中
接口相应的字节码文件必须在与包名称相匹配的目录结构中

接口与类的区别：　　

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。抽象类和接口的区别
1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口有以下特性：　　

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
接口中的方法都是公有的。

序列化

将对象转化成字节存储，保持对象连接，使用时需要进行反序列化，在java中实现序列化必须实现Serializable

java多线程

新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
就绪状态:
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
阻塞状态:
如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：

等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。

同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。

其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
死亡状态:
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。

Derek

Java学习总结