Java开发学习笔记 - 1

一 JAVA基础

package 包的命名一般都是以自己公司或企业的域名进行规范

1 类

格式：
public class 类名称{
//…
}

一个标准的类通常要拥有四个组成部分：
（1）所有的成员变量都要使用private关键字修饰
（2）为每一个成员变量编写一对Getter/Setter方法（可以利用IDEA自动生成，code-generate）
（3）编写一个无参数的构造方法（可以利用IDEA自动生成，code-generate）
（4）编写一个全参数的构造方法（可以利用IDEA自动生成，code-generate）

这样标准的类也叫做java Bean

2 方法

方法其实就是若干语句的功能集合。

1 格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，…){
…//方法体
return 返回值；
}

修饰符：现阶段的固定写法 public static
命名规则：小驼峰式

（2）方法的调用
调用格式：
方法名称（）；

3 方法的重载（overload）：多个方法的名称一样，但是参数列表不一样

4 构造方法

常用的类

（1）String类

String 三种构造方法：
public String（）：创建一个空白字符串，不含任何内容
public String（char[] array):根据字符数组的内容，来创建对应的字符串。
public String (byte[] array)：根据字节数组的内容，来创建对应的字符串。
String 一种直接创建方法

常用方法：
isEmpty() 当且仅当 length() 为 0 时返回 true。
concat(String str) 将指定字符串连接到此字符串的结尾。
equals(Object anObject) 将此字符串与指定的对象比较。
length() 返回此字符串的长度
replace(char oldChar, char newChar) 返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
split(String regex) 根据给定正则表达式的匹配拆分此字符串。
（分割后的字符串数组，可以输出出来可以用Arrays.toString(字符串数组名称)）.

String s2 = "aBc:deF:123";
String[] ss = s2.split(":");
String arrays =Arrays.toString(ss);
System.out.println(arrays);

substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符串。
toCharArray() 将此字符串转换为一个新的字符数组。

（2） Math

Math.abs(); //求绝对值
Math.ceil(); //向上取整

（3）Scanner

先创建一个对象，再调用
Scanner sc = new Scanner(System.in); //sc 是 " 对象名称 "
sc.nextInt();
sc.next();

（4）Random

先创建一个对象，再调用
Random ra = new Random(); //ra是 '" 对象名称 "
ran.nextInt(); //随机数的范围是Int整个范围
ran.nextInt(bound：5); //随机数范围是[0,5）；左闭右开，不包含5

**

二 面向对象

三大特性：

1 封装
（1）方法就是一种封装
（2）关键字private也是一种封装

2 继承
（1） 格式
定义父类的格式：（一个普通的类定义）
public class 父类名称（）{
…
}

定义一个子类格式：
public class 子类名称 extends 父类名称{
…
}
（2）使用
访问成员变量的两种方式：
1 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找；
2 间接通过成员方法访问成员变量。

访问成员方法的方式：
在父子类的继承关系当中，创建子类对象，访问成员方法的规则：
创建的对象是谁（等号左边），就优先用谁，没有则向上找。

创建对象进行调用
父类名称 父类对象名称 = new 父类名称（）; // 创建父类对象
调用：父类对象名称.成员变量/成员方法；
注意：只能使用父类的东西

子类名称 子类对象名称 = new 子类名称（）; //创建子类对象
调用：子类对象名称.成员变量/成员方法；

注意：成员变量优先用子类的，成员方法：创建的对象是谁，就优先用谁，没有则向上找。对于重名的成员变量：this，super进行访问；对于重名的成员方法：创建的对象是谁，就优先用谁，没有则向上找。

3 多态
一个对象拥有多种形态，这就是：对象的多态性。
代码当中体现多态性：父类引用指向子类对象

（1） 创建格式
父类名称 对象名 = new 子类名称（）； //extends
或者
接口名称 对象名 = new 实现类名称（）； //implements

访问成员变量的两种方式：
1 直接通过对象名称访问成员变量：看等号左边是谁，优先用谁，没有则向上找；
2 间接通过成员方法访问成员变量：看该方法属于谁，优先用谁，没有则向上找。
（如果父类中的方法，子类没有覆盖重写，则访问的是父类的成员变量，如果子类覆盖重写了，则访问的是子类的成员变量。）
口诀：编译看左，运行还看左。

访问成员方法的规则：
看new的是谁，就优先用谁，没有则向上找。
口诀：编译看左，运行看右。

========================================================
4 匿名对象
格式
new 类名称（）；
匿名对象只能使用一次；

三 接口

接口就是多个类的公共规范。
接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

1 接口格式：
public interface 接口名称{
…//接口内容
}

2 接口使用：
（1）接口不能直接使用，必须有一个实现类来实现该接口。
格式：
public class 实现类名称 implements 接口名称 {
//…
}
（2）接口的实现类必须覆盖重写（实现）接口中所有的抽象方法 。
实现：去掉abstract关键字，加上方法体大括号

（3） 创建实现类的对象，用对象进行调用。

四 容器（集合）

Collection 集合

Collection集合是所有单列集合的父接口。

方法
Collections.sort（list） //升序排列

 如果对自定义的类进行sort，需要将自定义类实现Comparable的接口，
        并需要重写comparableTo方法

        public static <T> void sort(List<T> list,Comparator<? super T>):
        将集合中元素按照指定规则排序

        Comparator 和 Comparable 的区别
            Comparable：自己（this）和别人（参数）比较，自己需要实现Comparable接口，
                        重写比较的规则compareTo方法
            Comparator:相当于找一个第三方的裁判，比较两个

        其实可以用Comparator进行实现
        o1 - o2 升序
        o2 - o1 降序
package ang.excise.demo;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;

public class CollectionsDemo1 {
    public static void main(String[] args) {
ArrayList<Student> list01 = new ArrayList<>();

        list01.add(new Student("小米",10));
        list01.add(new Student("红米",18));
        list01.add(new Student("荣耀",18));
        list01.add(new Student("OPPO",15));

        System.out.println(list01);

        Collections.sort(list01, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //按照年龄升序进行排序
                int result = o1.getAge() - o2.getAge();
                //如果两人年龄相同，再使用姓名的第一个字比较
                if(result == 0){
                    result = o1.getName().charAt(0) - o2.getName().charAt(0);
                }
                return result;
            }
        });
        System.out.println(list01);
    }
}

List集合：底层是 数组，增删快，查询慢

set集合：底层是hash表，查询快

字符串截取：对象名称.substring(字符串名称)

字符串分割：对象名称.split(f“分割符”)

哈希表组成：
哈希表：数组+链表/红黑树

List集合

常用方法：
（1）add(int index，E element) 将指定的元素，添加到该集合中的指定位置上
（2）get(int index) 返回集合中指定位置的元素
（3）remove(int index)移除列表中指定位置的元素，返回的是被移除的元素
（4）set(int index,E element) 用指定元素替换集合中指定位置的元素，返回值的是更新前的元素
（5）size() 返回列表中的元素数。
（6）toArray() 返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。

List的子集合
（1） ArrayList集合
底层是数组，增删慢，查询快
原因：增删慢的原因：每添加一个元素都需要调用一个数组复制的方法，（数组长度加1，然后将数组的元素复制给新数组）
查询快的原因：数组是连续的，地址是连续的
多线程
数组的长度是不可以发生改变，但ArrayList集合的长度是可以随意变化的。

使用：
先创建一个对象，再调用
ArrayList<包装类> 数组名称 = new ArrayList<>();
泛型只能是引用类型，不能是包装类型

如果希望像集合ArrayList当中储存基本类型数据，必须使用基本类型对应的"包装类“
基本类型 包装类 （引用类型，包装类都位于java.lang包下）
byte Byte
short Short
int Integer 【特殊】
long Long
float Float
double Double
char Character 【特殊】
boolean Boolean

（2）LinkList集合
底层是链表：增删快，查询慢
多线程
常用方法：
addFirst(E e)
将指定元素插入此列表的开头。
addLast(E e)
将指定元素添加到此列表的结尾。

getFirst()
返回此列表的第一个元素。
getLast()
返回此列表的最后一个元素。
removeFirst()
移除并返回此列表的第一个元素。
removeLast()
移除并返回此列表的最后一个元素。

pop()
移除并返回此列表的第一个元素。此方法等效于removeFirst()。
push(E e)
将该元素插入此列表的开头。 此方法等效于addFirst(E)。

Set集合

不允许储存重复元素
没有索引，不能使用普通for循环遍历

根据哈希值进行分组，相同哈希值的元素放在一起，查询快，链表长度超过8位，就会把链表转换为黑树（提高查询的速度）

相同哈希值（哈希冲突）
（1）HashSet（Set的子类）
不允许储存重复元素

HashSet中保证集合中元素是唯一的方法：
通过对象的hashCode和equals方法来完成对象唯一性的判断。
如果对象的hashCode值不同，则不用判断equals方法，就直接存到HashSet中。
如果对象的hashCode值相同，需要用equals方法进行比较，如果结果为true，则视为相同元素，不存，如果结果为false，视为不同元素，进行存储。

没有索引，不能使用普通for循环遍历
底层是HashMap（查询速度非常快）

（2）LinkedHashSet（Set的子类，HashSet的子类）
底层是数组+链表/红黑树

（3）TreeSet（SortedSet的实现类）
Treeset中的数据是排好序的，不允许放入null值。
TreeSet是通过TreeMap实现的,只不过Set用的只是Map的key。
TreeSet的底层实现是采用二叉树（红-黑树）的数据结构。

Map集合

Map是一个双列集合，一个元素包含两个值（一个key,一个value）
key和value数据类型可以想通过，可以不同
key不允许重复，value可以

常用方法：
put(K key,V value)：
remove()：
get(Object key)：
containkey(Object key):判断集合是否包含指定的值，包含返回ture,不包含返回false

Entry键值对
Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图

//创建Map集合对象
Map<String,Integer> map = new HashMap<>(); 
//使用Map集合中的方法entryset()，把Map集合多个Entry对象取出来，储存到一个Set集合中         
Set<Map.Entry<String,Integer>> set = map.entrySet();

（1）HashMap
底层是哈希表，是一个无序的集合，储存元素和取出元素的顺序可能不一致

多线程
（2）LinkedHashMap
底层是哈希表+链表（保证迭代的顺序），有序的集合，储存元素和取出元素的顺序一致

多线程
（3）HashTable
HashMap，集合可以储存null键，null值
HashTable 不能储存null值null键
单线程，线程安全的

五 循环

1 普通for循环

2 迭代器 Iterator

//创建一个迭代器对象
Iterator<包装类> it = 集合对象名称.iterator();
while (it.hasNext){
     参数类型 参数名称 = it.next();
     sout("参数名称"）;

3 增强for循环

for(参数类型 参数名称 ：数组名称){
     sout("参数名称")
}

六 异常

throw关键字
throws关键字

try{
可能产生异常的代码
}catch(异常类名 变量名){
异常的处理
}finally{.
无论是否出现异常都会执行的代码
}

七 IO流

（1）字节流
InputStream 字节输入流：把硬盘文件中的数据读取到内存中使用
构造方法：
FileInputStream
方法：read

OutputStream 字节输出流：把内存中的数据写入到硬盘的文件中
构造方法：
FileOutputStream
方法：write

（2）字符流
Reader 字符输入流 ：把硬盘中的文件以字符的方式读取到内存中
构造方法：
FileReader

Writer 字符输出流：把内存中的字符数据写入到文件中

构造方法：
FileWriter

flush() //刷新
close() //释放资源

（3）Properties 集合
Properties 可保存在流中或从流中加载。
Properities 是一个双列集合，key和value默认都是字符串

setProperty(String key, String value)
调用 Hashtable 的方法 put。

getProperty(String key)
用指定的键在此属性列表中搜索属性。

stringPropertyNames()
返回此属性列表中的键集，其中该键及其对应值是字符串，如果在主属性列表中未找到同名的键，则还包括默认属性列表中不同的键。 相当于keySet方法

store(OutputStream out, String comments)
以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。（不可以写中文）

store(Writer writer, String comments)
以适合使用 load(Reader) 方法的格式，将此 Properties 表中的属性列表（键和元素对）写入输出字符。 （可以写中文）

load(InputStream inStream)
从输入流中读取属性列表（键和元素对）。

（4）缓冲流
字节缓冲流：
字节缓冲输入流 BufferedIntputStream
字节缓冲输出流 BufferedOutputStream

字符缓冲流:
字符缓冲输入流 Bufferedreader
字符缓冲输出流 BufferedWriter

（5）序列化和反序列化

序列化
把对象以流的方式，写入到文件中保存，叫写对象，也叫对象的序列化
对象中保存的不仅仅是字符，使用字节流
ObjectOutputStream：对象的序列化流

一个对象想要序列化
必须实现java.io.Serializable接口;
该类的所有属性必须是可序列化的
使用步骤：
（1）创建ObjectOutputStream对象
（2）使用ObjectOutputStream中的writeObject方法
（3）释放资源

（2）反序列化
把文件中保存的对象，以流的方式读取出来，叫做读对象，也叫对象的反序列化流
读取的文件保存的都是字节流，使用字节流
ObjectInputStream：对象的反序列化流
使用Object obj = （new 的对象）接收这个对象

使用步骤：
（1）创建ObjectInputStream对象
（2）使用ObjectInputStream中的readObject方法，用Object 型 接收
（3）释放资源

八 反射

反射：将类的各个组成部分封装为其他对象，这就是反射机制

九 注解

注解：说明程序的。给计算机看的
注释：用文字描述程序的，给程序员看的

作用：
编写文档：通过代码里标识的注解生成文档（生成文档doc文档） 在系统窗口 输入 javadoc 类名
代码分析：通过代码里标识的注解对代码进行分析
编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查

JDK中预定义的一些注解：
@override：检测该注解标注的方法是否继承自父类（接口）的

@Deprecated:该注解标注的内容，表示已过时

@SuppressWarnings:压制警告
（使用@SuppressWarnings(“all”）需要传参all）

自定义注解：
javac 文件名 ：编译
javap 文件名 ：反编译