二、Java基础复习②

字符串：一串由字符组成的数组。
特性：所有使用双引号包围起来的字符，都是字符串的对象。字符串中的每一个字符都是使用Unicode字符集编码。
例如：

String str = "HelloWorld";
String str = new String("hello");

构造方法的作用：创建对象，并对对象进行赋初值

常用的方法：（标注粗体的为常用方法）
1、length();返回字符串的长度
2、charAt(int index);返回指定索引处的char值
3、compareTo(String str1):按照字典顺序比较两个字符串大小，返回值是int类型。如果 调用方法的字符串比参数字符串大则返回一个正数，如果调用的方法的字符串比参数字符串小则返回一个负数，否则两个字符串的内容一致。
4、compareToIgnoreCase(String str1)：按照字典顺序比较两个字符串大小，返回值是int类型。如果 调用方法的字符串比参数字符串大则返回一个正数，如果调用的方法的字符串比参数字符串小则返回一个负数，否则两个字符串的内容一致。但是不区分大小写
5、concat(String str1):将参数字符串连接到调用方法的字符串的结尾。此方法的返回值是一个字符串对象
6、contains(String str1):判断调用方法的字符串中是否包含并且是连续包含参数字符串。返回值类型是boolean类型
7、endsWith(String str1):判断调用方法的字符串是否以参数字符串结尾。返回值类型是boolean 类型
8、startsWith(String str1):判断调用方法的字符串是否以参数字符串开头。返回值类型是boolean 类型
9、equals(String str1):比较调用方法的字符串与参数字符串的字面值是否相等。返回结果是boolean类型
10、indexOf(int c):判断参数字符在字符串中第一次出现的位置，如果存在则返回第一次出现的下标，如果不存在则返回-1.
11、indexOf(int c,int index):判断参数字符在字符串中指定的index这个下标的后面第一次出现的位置，如果存在则返回第一次出现的下标，如果不存在则返回-1.
12、indexOf(String str1):判断参数字符串在字符串中第一次出现的位置，如果存在则返回第一次出现的下标，如果不存在则返回-1.
13、indexOf(String str1,int index):判断参数字符串在字符串中指定的index下标后第一次出现的位置，如果存在则返回第一次出现的下标，如果不存在则返回-1.
14、lastIndexOf(int c):判断参数字符在字符串中最后一次出现的位置，如果存在则返回第一次出现的下标，如果不存在则返回-1.
15、lastIndexOf(int c,int index):判断参数字符在字符串中指定的index这个下标的后面最后一次出现的位置，如果存在则返回第一次出现的下标，如果不存在则返回-1.
16、lastIndexOf(String str1):判断参数字符串在字符串中最后一次出现的位置，如果存在则返回第一次出现的下标，如果不存在则返回-1.
17、lastIndexOf(String str1,int index):判断参数字符串在字符串中指定的index下标后最后一次出现的位置，如果存在则返回第一次出现的下标，如果不存在则返回-1.
18、replace(char c,char c1):使用c1字符将字符串中所有的c字符进行替换，返回值是String类型
19、replace(CharSequence c,CharSequence c1):使用c1字符串将字符串中所有的c字符串进行替换，返回值是String类型
注意：CharSequence可以理解为字符串。
20、split(String str):将字符串按照参数字符串进行拆分，拆分成一个字符串数组，返回值是字符串数组。
22、substring(int index):从指定的index下标开始截取字符串，从index开始接到length()-1,返回值是String类型
/23、substring(int index,int index1):从指定的index下标开始截取字符串，从index开始截取到index1，但是不包含index1,返回值是String类型
24、toCharArray():将字符串转变为字符型数组。返回值是char[]类型
25、toLowerCase():根据语言环境将字符串中所有的字母都变为小写字母
26、toUpperCase():根据语言环境将字符串中所有的字母都变为大写字母
27、trim():去掉字符串两边的空格
字符串是一个常量，其内容一旦指定就不能更改。
当大量拼接字符串的时候不建议使用+""这种形式，因为会产生大量的对象，占用内存，造成资源的浪费。

StringBuffer与StringBuilder的区别
StringBuffer线程安全的可变的字符串序列
StringBuilder线程不安全的可变的字符串序列，比StringBuilder快
常用方法append()：

public class Test {
    public static void main(String[] args) {
        StringBuffer buf=new StringBuffer("Hello ");
        char[] text ={'W','a','x','w','o','r','l','d'};
        buf.append(text ,3,5);
        System.out.println(buf);
    }
}

运行结果

Hello world

==与equals的区别
==：基本数据类型比较的是值；引用类型比较的是地址值。
equals()：先比较地址在比较值
equles源码：

 public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

面向对象的特性：
封装，继承，多态(不过多阐述)
java中有个就近原则：在一个方法中，一个范围小属性的会将一个范围大的属性覆盖，因此，常常采用this强调本类中的属性

this关键字：
1.强调本类中的属性以及方法
2.调用本类中的构造方法
注意：1.使用this调用构造方法的时候，语句必须写在构造方法的第一行
2.使用this调用构造方法的时候，构造方法之间不能相互调用。
3.代表当前对象（当前正在调用方法的对象）

static关键字：使用static关键字声明的属性，不再归某一个对象所拥有了，而是归这个类的所有的对象共享。
作用：1.用来修饰属性，static所修饰的属性被称为静态属性。
2.用来修饰符方法，static所修饰的方法被称为静态方法。
一般来讲对于静态属性或者静态方法，我们可以不用再通过对象去调用，而是直接通过类名调用
注意：静态方法中只能调用静态属性或者是静态方法，不能调用非静态属性或者是非静态方法。

代码块：
{}代表代码块，代码块可以写在一个类中的任意的位置，只不过名称不一样：
1.普通代码块：写在方法中的。
2.构造块：写在方法的外面，类的内部。在创建对象的时候，构造块会优先于构造方法执行。
3.静态代码块：使用static修饰的构造块
静态代码块是在类被加载的时候就会执行，是优先于构造块以及构造方法，被第一个执行的代码块，但是静态块只执行一次。
执行顺序：静态代码块>构造块>构造方法。

单例设计模式
一、基本模式

public class Single {
    private static Single single;
    private Single(){
        
    }
    static {
        single= new Single();
    }
    public static Single getSingle(){
        return single;
    }
}

二、懒汉模式

public class Single {
   private static Single single=null;
   public static synchronized Single getSingle(){
       if (single!=null)
           single=new Single();
       return single;
   }
}

饿汉模式：

public class Single {
   private static Single single=new Single();
   private Single(){
       
   }
   public static Single getSingle(){
       return single;
   }
}

super关键字
1.强调父类中的属性以及方法。
2.调用父类的构造方法
如果子类中有跟父类相同的属性，则子类中的属性会将父类中的属性进行覆盖。如果想要使用父类中的属性，则需要使用super关键字进行强调。

方法的重载overload：
发生在同一个类中，方法之间的方法名一致，参数列表不同，参数列表的不同是指，参数的个数不同，参数的类型不同，参数的类型的顺序不同。
方法的重写override
在子类与父类中，子类的方法与父类的方法要求，方法的返回值类型，方法名称，参数列表全都一致。子类的访问权限不能比父类的更加严格。

final关键字：
1.final关键字修饰的变量被称作是常量，常量的值一旦被指定就不能更改。
2.final关键字可以修饰类，使用final关键字修饰的类，不能被继承。
3.final关键字可以修饰方法，使用final关键字修饰的方法，不能被重写。

抽象类的定义及使用规则
1包含一个抽象方法的类必须是抽象类；
2抽象类和抽象方法都要使用abstract关键字声明；
3抽象方法只需声明而不需要实现；
4抽象类必须被子继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法
抽象类的构造方法的作用：不是用来创建对象的，而是用来初始化类中的属性。

接口不能直接创建对象。需要有一个子类去实现这个结构，然后通过这个子类创建对象。
子类实现接口之后，必须重写接口中全部的抽象方法，如果不重写全部的抽象方法，那么这个子类只能是抽象类。
子类实现接口之后，会拥有接口中全部的全局常量。

多态：指的就是一种事物的多种表现形态。
java中多态体现在：
1.方法的重载与重写
2.对象的多态性
对象的多态性体现在两个方面
1.向上转型：就是把一个子类的对象，赋值给父类对象，会完成自动类型转换，父类对象只能调用父类与子类共有的方法，如果子类对方法进行了重写，那么则执行子类重写过的。
2.向下转型:就是把一个父类对象，赋值给子类对象，需要进行强制类型转换。
注意：
1.发生向下转型之前，需要先发生向上转型
2.向下转型的时候，必须转到向上转型的时候的子 类类型。
instanceof：java中的一个关键字，用来判断父类类型是由哪一个子类类型发生的向上转型。
例如：

boolean  result = obj instanceof class
//注意obj不能为空，不能为基本数据类型

对异常的处理：小范围的异常处理一定要在 大范围的异常处理前面
例如，Exception放在最前面，后面的异常捕获不到
自定义异常类

public class Test {
    public static class MyException extends Exception{
        public MyException(String msg){
            super(msg);
        }
    }
    public static class Main{
        public static void main(String[] args) {
            try {
                throw new MyException("自定义异常");
            } catch (MyException e) {
                System.out.println(e.getMessage());
            }
        }
    }
}

输出结果

自定义异常

访问权限
1.private:只有在本类中可以访问。在其他的类中是不能被访问的。
2.default:在声明属性或者是方法的时候，什么都不写默认的就是default权限。
在本类中可以访问，在同一个包的子类中可以访问，同一个包中的其他的类可以访问，其他包中的所有的类都不能访问。
3.protected：本类中可以访问，同一个包中的所有的类都能访问。其他包中的子类可以访问，其他包中的其他类不能访问。
4.public:任意的位置都可以访问

进程：在计算机上单独运行的某一个程序，我们称之为进程。如果某一个操作系统，“同时”只能运行一个程序，我们称之为单进程操作系统。但是我们使用windows操作系统是多进程的操作系统，“同时”可以运行多个程序。
线程：相比较于进程而言，是一个程序的更小的可执行单元。一般我们可以将线程理解为，某一个功能。如果程序能够“同时”执行多个线程的话，我们称这个程序是一个多线程程序。

Java中如何实现线程：
1.继承Thread类，重写一个方法：run()
2.实现Runnable接口,重写run方法。
注意：启动线程的时候，不能调用run方法而是要调用start方法。

线程的状态（线程的生命周期）
1.新建的状态：Thread thread = new Thread ();
2.就绪状态：调用start()方法后，即可启动线程，启动后进入就绪状态，此时线程进入线程队列等待CPU分配时间。
3.运行状态：调用run()方法后就进入运行状态，该方法定义了该线程的操作和功能。
4.阻塞状态：被认为挂起的或执行耗时的输入输出操作，线程让出CPU，阻塞的线程不能进入排队队列，阻塞解除后进入就绪状态
5.销毁状态：使用stop()方法或者run()方法执行完毕。

常用方法：
1.setName();设置线程的名称
2.getName();取得线程的名称
3.currentThread();取得当前正在运行的线程对象。
4.isAlive():判断线程是否启动
5.join();让一个线程强制执行，如果强制执行的线程没有执行结束，其他的线程 不能执行。
6.sleep(long millis);对线程设置一个休眠时间，此时间是毫秒数，让线程进行到阻塞状态，时间一到线程自动回到就绪状态。
7.interrupt()：让一个线程中断
8.setDaemon(boolean flag):设置当前线程是否是后台线程。
9.setPriority(int flag);设置线程的优先级
10.wait()方法：让线程等待，需要notify或者notifyAll唤醒，唤醒后就进如就绪状态

线程的同步：
Java中有2种可以实现线程同步的方式：
1.同步块
语法：
synchronized (同步的对象) {
需要同步的代码
}
2.同步方法
语法：
访问权限修饰符 【static】【final】【synchronized 】返回值类型 方法名称(参数列表)【throws 异常1,…,异常n】{
方法体
【return 】
}
生产者消费者

//info类
public class Info {
    private String name;
    private String text;
    private boolean flag=true;
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }
    public synchronized void setInfo(String name ,String text){
        if (flag==false){
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.setName(name);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.setText(text);
        flag=false;
        super.notify();
    }
    public synchronized void getInfo(){
        if (flag==true){
            try {
                super.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.getName();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.getText();
        System.out.println(this.getName()+this.getText());
        flag=true;
        super.notify();
    }
}

//Customer类
public class Customer implements Runnable{
    private Info info;
    private boolean flag=true;
    public Customer(Info info){
        this.info=info;
    }
    @Override
    public void run() {
        for (int i=0;i<10;i++)
            info.getInfo();
    }
}

//Product类
public class Producter implements Runnable{
    private Info info;
    private boolean flag = true;
    public Producter(Info info){
        this.info=info;
    }
    @Override
    public void run() {
        for (int i=0;i<10;i++){
            if (flag){
                info.setInfo("生产者生产","电脑");
                flag=false;
            }
            else{
                info.setInfo("消费者消费","电脑");
                flag=true;
            }
        }
    }
}

//Test类
public class Test {
    public static void main(String[] args) {
            Info info =new Info();
            Producter producter= new Producter(info);
            Customer customer = new Customer(info);

            Thread pro =new Thread(producter);
            Thread cus =new Thread(customer);

            pro.start();
            cus.start();

    }
}

受限泛型：
在引用传递中，泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类，而范围下限使用super进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至Object类。 具体格式如下：
设置上限：
声明对象：类名称<? extends 类> 对象名称
定义类：[访问权限] 类名称<泛型标识 extends 类>{}
设置下限：
声明对象：类名称<? super 类> 对象名称
定义类：[访问权限] 类名称<泛型标识 extends 类>{}