Java 学习开发记录基础

Java中的Enum

// 使用枚举类替代静态常量可以
// 枚举类不可再被继承，即是final
public enum TestEnum {
    // 枚举值出现在首位，静态常量 
    RED(255,0,0),BLUE(0,0,255),GREEN(0,255,0);
    
    // 提供私有的构造函数
    private TestEnum(int rv, int gv, int bv) {
        this.redValue = rv;
        this.greenValue = gv;
        this.blueValue = bv;
    }
    // 自定义数据域
    private int redValue;
    private int greenValue;
    private int blueValue;
    public int getRedValue() {
        return redValue;
    }
    public int getGreenValue() {
        return greenValue;
    }
    public int getBlueValue() {
        return blueValue;
    }
}

所有枚举类都继承了Enum的方法
       (1) ordinal()方法: 返回枚举值在枚举类种的顺序。这个顺序根据枚举值声明的顺序而定。
                 Color.RED.ordinal(); //返回结果：0
                 Color.BLUE.ordinal(); //返回结果：1
       (2) compareTo()方法: Enum实现了java.lang.Comparable接口，因此可以比较象与指定对象的顺序。Enum中的compareTo返回的是两个枚举值的顺序之差。当然，前提是两个枚举值必须属于同一个枚举类，否则会抛出ClassCastException()异常。(具体可见源代码)
                 Color.RED.compareTo(Color.BLUE); //返回结果 -1
       (3) values()方法：静态方法，返回一个包含全部枚举值的数组。
                 Color[] colors=Color.values();
                 for(Color c:colors){
                        System.out.print(c+",");
           }//返回结果：RED,BLUE,BLACK YELLOW,GREEN,
       (4) toString()方法：返回枚举常量的名称。
                 Color c=Color.RED;
                 System.out.println(c);//返回结果: RED
       (5) valueOf()方法：这个方法和toString方法是相对应的，返回带指定名称的指定枚举类型的枚举常量。
                 Color.valueOf("BLUE");   //返回结果: Color.BLUE
       (6) equals()方法：比较两个枚举类对象的引用。

Java boolean类型

有关java boolean类型的定义：　　

　　The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This data type represents one bit of information, but its "size" isn't something that's precisely defined.

JVM规范并没有给出java boolean类型长度的定义，其长度可以是1个字节，或是4个字节。1个字节的考虑是从储存空间方面去考虑，使用4个字节在于现代计算机系统一次处理4个字节效率会更高

使用clone

1、继承Cloneable接口

2、重写clone方法

3、在clone方法中调用super.clone()

4、把浅复制的引用指向原型对象新的克隆体

Java Stream

Stream 有两种类型的操作：Intermedidate操作和Terminal操作

Intermedidate（中间操作）：Stream可以有多个Intermediate操作，Intermedidate操作是惰性化的，当调用到该方法时，并没有真正开始Stream遍历

　　核心操作方法：

　　　　filter

　　　　map

　　　　sorted

Terminal（结束操作）：一个Stream只有一个Terminal操作，Terminal操作是Stream的最后一个操作，这时候开始Stream的遍历

　　常见几个方法：

　　　　forEach

　　　　collect

　　　　xxxMatch

　　　　count

　　　　reduce

Java序列化技术

用序列化来存储对象。
先定义一个用来序列化的类：
 
package io.xuliehua;
import java.io.*;
public class Student implements Serializable{
    private String name;
    private String ID;
    private int age;
    private String specialty;
    public Student(String name, String ID, int age, String specialty){
        this.name=name;
        this.ID=ID;
        this.age=age;
        this.specialty=specialty;
    }
    
    public Student(){}
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    
    public String getID() {
        return ID;
    }
    public void setID(String iD) {
        ID = iD;
    }
    
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    
    public String getSpecialty() {
        return specialty;
    }
    public void setSpecialty(String specialty) {
        this.specialty = specialty;
    }
    
    public String toString(){
        return "姓名："+name+"  学号："+ID+"  年龄："+age+"  专业："+specialty;
    }
}
 
package io.xuliehua;
import java.io.*;
public class ObjectFileTest {
 
    public static void main(String[] args) {
        Student st = new Student("周勇","20140101",18,"计算机");
        try {
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("save.dat"));
            out.writeObject(st);
            out.close();
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("save.dat"));
            Student pupil = (Student)in.readObject();
            in.close();
            System.out.println(pupil);
            System.out.println("姓名："+pupil.getName());
            System.out.println("学号："+pupil.getID());
            System.out.println("年龄："+pupil.getAge());
            System.out.println("专业："+pupil.getSpecialty());
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block            e.printStackTrace();
        }
        
 
    }
 
}
 
Java注解元注解：
　　@Target,
　　@Retention,
　　@Documented,
　　@Inherited
@Target：
　　@Target说明了Annotation所修饰的对象范围：Annotation可被用于 packages、types（类、接口、枚举、Annotation类型）、类型成员（方法、构造方法、成员变量、枚举值）、方法参数和本地变量（如循环变量、catch参数）。在Annotation类型的声明中使用了target可更加明晰其修饰的目标。
　　作用：用于描述注解的使用范围（即：被描述的注解可以用在什么地方）
　　取值(ElementType)有：
　　　　1.CONSTRUCTOR:用于描述构造器
　　　　2.FIELD:用于描述域
　　　　3.LOCAL_VARIABLE:用于描述局部变量
　　　　4.METHOD:用于描述方法
　　　　5.PACKAGE:用于描述包
　　　　6.PARAMETER:用于描述参数
　　　　7.TYPE:用于描述类、接口(包括注解类型) 或enum声明
 
@Retention：
　　@Retention定义了该Annotation被保留的时间长短：某些Annotation仅出现在源代码中，而被编译器丢弃；而另一些却被编译在class文件中；编译在class文件中的Annotation可能会被虚拟机忽略，而另一些在class被装载时将被读取（请注意并不影响class的执行，因为Annotation与class在使用上是被分离的）。使用这个meta-Annotation可以对 Annotation的“生命周期”限制。
　　作用：表示需要在什么级别保存该注释信息，用于描述注解的生命周期（即：被描述的注解在什么范围内有效）
　　取值（RetentionPoicy）有：
　　　　1.SOURCE:在源文件中有效（即源文件保留）
　　　　2.CLASS:在class文件中有效（即class保留）
　　　　3.RUNTIME:在运行时有效（即运行时保留）
　　
@Documented:
　　@Documented用于描述其它类型的annotation应该被作为被标注的程序成员的公共API，因此可以被例如javadoc此类的工具文档化。Documented是一个标记注解，没有成员。
 
 
@Inherited：
 
　　@Inherited 元注解是一个标记注解，@Inherited阐述了某个被标注的类型是被继承的。如果一个使用了@Inherited修饰的annotation类型被用于一个class，则这个annotation将被用于该class的子类。
 
　　注意：@Inherited annotation类型是被标注过的class的子类所继承。类并不从它所实现的接口继承annotation，方法并不从它所重载的方法继承annotation。
 
　　当@Inherited annotation类型标注的annotation的Retention是RetentionPolicy.RUNTIME，则反射API增强了这种继承性。如果我们使用java.lang.reflect去查询一个@Inherited annotation类型的annotation时，反射代码检查将展开工作：检查class和其父类，直到发现指定的annotation类型被发现，或者到达类继承结构的顶层。
 
　　
自定义注解：
　　使用@interface自定义注解时，自动继承了java.lang.annotation.Annotation接口，由编译程序自动完成其他细节。在定义注解时，不能继承其他的注解或接口。@interface用来声明一个注解，其中的每一个方法实际上是声明了一个配置参数。方法的名称就是参数的名称，返回值类型就是参数的类型（返回值类型只能是基本类型、Class、String、enum）。可以通过default来声明参数的默认值。
　　定义注解格式：
　　public @interface 注解名 {定义体}
　　注解参数的可支持数据类型：
　　　　1.所有基本数据类型（int,float,boolean,byte,double,char,long,short)
　　　　2.String类型
　　　　3.Class类型
　　　　4.enum类型
　　　　5.Annotation类型
　　　　6.以上所有类型的数组
　　Annotation类型里面的参数该怎么设定: 
　　第一,只能用public或默认(default)这两个访问权修饰.例如,String value();这里把方法设为defaul默认类型；　 　
　　第二,参数成员只能用基本类型byte,short,char,int,long,float,double,boolean八种基本数据类型和String,Enum,Class,annotations等数据类型,以及这一些类型的数组.例如,String value();这里的参数成员就为String;　　
　　第三,如果只有一个参数成员,最好把参数名称设为"value",后加小括号.例:下面的例子FruitName注解就只有一个参数成员。
 
Java泛型：泛型类、泛型接口和泛型方法原文出自：https://segmentfault.com/a/1190000002646193
泛型类
 
public class Container<K, V> {
    private K key;
    private V value;

    public Container(K k, V v) {
        key = k;
        value = v;
    }

    public K getKey() {
        return key;
    }

    public void setKey(K key) {
        this.key = key;
    }

    public V getValue() {
        return value;
    }

    public void setValue(V value) {
        this.value = value;
    }
} 
泛型接口

public interface Generator<T> {
    public T next();
}
 
public class FruitGenerator implements Generator<String> {

    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};

    @Override
    public String next() {
        Random rand = new Random();
        return fruits[rand.nextInt(3)];
    }
} 
泛型方法（一个基本的原则是：尽量使用泛型方法）

    public static <T> void out(T t) {
        System.out.println(t);
    }
类型通配符（存在普通方法中，在不使用泛型方法时使用）
　　上限：<? extends T> ?是T和T的子类
　　下限：<? super T> ?是T和T的父类
Java内部类部类是指在一个外部类的内部再定义一个类。类名不需要和文件夹相同。
*内部类可以是静态static的，也可用public，default，protected和private修饰。（而外部顶级类即类名和文件名相同的只能使用public和default）。
 
1、非静态内部类： 
       ● 外围类和内部类可互相访问自己的私有成员。
       ● 内部类中不能定义静态成员变量。
 
2、静态内部类：
       ● 只能访问外部类的静态成员。
 
3、局部内部类：
       ● 该内部类没有任何的访问控制权限
       ● 外围类看不见方法中的局部内部类的，但是局部内部类可以访问外围类的任何成员。
       ● 方法体中可以访问局部内部类，但是访问语句必须在定义局部内部类之后。
       ● 局部内部类只能访问方法体中的常量，即用final修饰的成员。
 
4、匿名内部类：
       ● 没有构造器，取而代之的是将构造器参数传递给超类构造器。
 
Java 获取SQL查询语句结果step1:构造连接
Class.forName("com.mysql.jdbc.Driver"); 
Connection con = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/db","root","123"); 

step2:构造语句
String sql = "select username,password from t_user where username=?"; 
PreparedStatement stmt = con.prepareStatement(sql); 
stmt.setString(1, "zhangshan"); //给SQL的"?"（问号）传值。

step3:执行查询
ResultSet rs = stmt.executeQuery(); //rs就是SQL查询语句返回的结果集

step4:处理结果(java 获取SQL查询语句返回的结果)
        List list = new ArrayList();
        //遍历结果集，这样写就可以了，就是一个循环，有多少条记录，这里就会循环多少次，
        //一次就是一条记录，想像一下就像一个表的一条记录
       //在这里可以做查询出来的数据处理，可以封装成对象之类的（就是把值给它）
        if(rs.next()) { //遍历结果集，这样写就可以了
            User u = new User();
            String username = rs.getString("username"); 
            String address = rs.getString("password "); 
            u.setUsername(username);
            u.setAddress(address);
            list.add(u);
        } 
        //上面这个例子意思是，把每一条记录封装成了一个User对象，然后这些User对象都放存入到了一个list

step4:关闭连接等


不可变类设计方法1、添加 final 修饰符，保证类不被继承
2、保证所有成员变量必须私有，并且加上 final 修改符
3、不提供改变成员变量方法
4、通过构造器初始化所有成员，进行深拷贝
5、在 getter 方法中，不直接返回对象本身，而是对象克隆，深克隆
JAVA 编码解码涉及编码的地方一般都在从字符到字节或是从字节到字符间的转换上
1、在IO中存在的编码，主要是 FileOutputStream 和 FileInputStream，在使用时需要指定字符集，而不是使用系统默认的字符集

        FileInputStream inputStream  = new FileInputStream("file");
        InputStreamReader reader = new InputStreamReader(inputStream, "UTF-8");
        
        FileOutputStream outputStream  = new FileOutputStream("file");
        OutputStreamWriter writer = new OutputStreamWriter(outputStream, "UTF-8");
2、内存中编码
　　1）String 类方法

        String s = "中文";
        byte b[] = s.getBytes("UTF-8");
        String n = new String(b, "UTF-8");
　　2）Charset类

        Charset charset = Charset.forName("UTF-8");
        ByteBuffer byteBuffer = charset.encode("中文");
        CharBuffer charBuffer = charset.decode(byteBuffer);
　　注意：ByteBuffer 类虽然提供了 char 和 byte 间的转换，但只是单纯的字节拷贝

        ByteBuffer byteBuffer = ByteBuffer.allocate(1024).putChar('A');
 ClassLoader 工作机制ClassLoader 采用上级委托接待机制加载 class
JVM 平台提供三层 ClassLoader
　　1、Bootstrap ClassLoader：主要加载 JVM 自身工作需要的类
　　2、ExtClassLoader：加载 VIP 类
　　3、AppClassLoader：加载自定义类
 JVM在加载类之前会检查请求的请求的类是否已经被加载，也就是要调用 findLoadedClass() 方法查看是否能够返回类实例。
JVM表示一个类是否是同一个类会有两个条件：
　　1、类的完整类名是否一样
　　2、加载这个类的 ClassLoader 是否是同一个
实现类的热部署，可以创建不同的ClassLoader的实例对象，通过这个不同的实例对象来加载同名的类
ClassLoader 对象同样会被 GC 回收，只是在执行 Full GC 时才会被回收。
大端小端大端：高尾端，尾在高地址
小端：低尾端