Java SE 笔记

数据类型

基本数据类型

boolean
byte
short
char
int
long
float
double

数据类型转换

boolean byte->short,char->int->long->float->double
- 强制类型转换（类型）变量名高转低
- 自动类型转换低转高

int year = 888888;
int sum = 888888;
long total = year * sum;    //error:仍溢出
long total = year * (long)sum   //right

流程控制

Scanner

Scanner s = new Scanner(System.in);
s.next();       //空白作为终止
s.nextLine();   //回车作为终止

面向对象

本质：以类的方式组织代码，以对象组织（封装）数据
构造器
- 一旦有有参构造器，无参构造器必须显示定义
- IDEA->"Alt+Insert" 快捷键
修饰符
- public -> protected -> default -> private
三大特性
- 封装
  - 高内聚，低耦合 属性私有：get/set
  - 提高程序的安全性
  - 隐藏代码的实现细节
  - 统一接口
  - 提高系统的可维护性
- 继承
  - IDEA 快捷键 “Crtl+H" 继承树
  - Object类
  - super()
    - super调用父类的构造方法，必须是子类构造方法的第一行
    - super 和 this 不能在同一个构造方法
  - 私有（private）的无法被继承
  - 方法重写
    - 方法修饰符：范围可以扩大但不能缩小
    - 抛出异常：范围可以缩小不能扩大
```
  class A{
      public void test1(){};
      public static void test2(){};
  }
  class B extends A{
      public void test1(){};
      public static void test2(){};
  }
  
  A a = new B();  //父类的引用指向子类的对象
  a.test1();      //调用B类的test1方法
  a.test2();      //调用A类的test2方法
```
- 多态
  - 有继承关系|子类重写父类方法|父类引用指向子类对象
  - 方法的多态
  - static final private 无法被重写
  - instanceof
抽象类
接口
- 约束和实现分离 interface
- 默认 public abstract 方法|默认public static final 字段

内部类

成员内部类

public class Outer{
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    
    public class Inner(){
        public void in(){
            System.out.println("这是内部类的方法");
        }
        
        public void getId(){
            //内部类可获得外部类的私有字段
            System.out.println(id);
        }
    }
}

Outer out = new Outer();
//通过外部类构造内部类的对象
Outer.inner in = out.new Inner();
in.getId();

静态内部类

public class Outer{
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    
    public static class Inner(){
        public void in(){
            System.out.println("这是内部类的方法");
        }
    }
}

Outer out = new Outer();
//通过外部类构造内部类的对象
Outer.inner in = out.new Inner();

局部内部类

public class Outer{
    private int id;
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

匿名内部类
- 不把实列保存到对象中

异常

Throwable
- Error
- Exception
  - IOException
  - RuntimeException
"Ctrl+Alt+T"

网络编程

IP
- 公网（互联网）-私网（局域网）
  - 192.168.xx.xx
- InetAddress
端口
- 公有端口：0~1023
- 程序注册端口：1024~49151
- 动态、私有端口：49152~65535
- ```
netstat -ano    //查看所有端口
netstat -ano|findstr "端口号"
tasklist|findstr "端口号"
```
- InetSocketAddress

TCP

客户端-Socket
服务端-ServerSocket

package com.csf.net;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class TcpClientDemo1 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        try {
            InetAddress ip = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            socket = new Socket(ip, port);
            os = socket.getOutputStream();
            os.write("Hello, World".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}
----------------------------------------------------------------------------------
package com.csf.net;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo1 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            System.out.println("server is running");
            serverSocket = new ServerSocket(9999);
            socket = serverSocket.accept();
            is = socket.getInputStream();
//            byte[] buffer = new byte[1024];
//            int len;
//            while ((len=is.read(buffer)) != -1){
//                String msg = new String(buffer,0,len);
//                System.out.println(msg);
//            }
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len=is.read(buffer)) != -1){
                baos.write(buffer, 0, len);

            }
            System.out.println(baos.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

TCP 文件上传
- FileInputStream FileOutpuStream

UDP
- DatagramPacket
- DatagramSocket
URL

注解

元注解
- @Target : 注解可以用在的地方
- @Retention : SOURCE < CLASS < RUNTIME
  
  默认RUNTIME
- @Document
- @Inherit
注解中的方法实际上是申明了一个配置参数
方法名称即为参数的名称
方法返回值类型即为参数的类型(java 基本类型, Class, String, Enum)
采用default申明参数默认值
若只有一个参数，一般参数名为value
注解元素必须要有值，一般采用0,""作为默认值

反射

获得class对象的方式
1. Class.forName() 会被初始化
2. getClass()
3. 类名.class 不会被初始化
4. 基本类型包装类的Type属性，如：Integer.Type

package com.csf.reflect;

import java.lang.annotation.ElementType;

public class Demo2 {
    public static void main(String[] args) {
        Class c1 = Object.class;
        Class c2 = Comparable.class;
        Class c3 = String[].class;
        Class c4 = int[][].class;
        Class c5 = void.class;
        Class c6 = ElementType.class;
        Class c7 = Override.class;
        Class c8 = Integer.class;

        System.out.println(c1); 
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        System.out.println(c5);
        System.out.println(c6);
        System.out.println(c7);
        System.out.println(c8);
        
        //class java.lang.Object
      //interface java.lang.Comparable
      //class [Ljava.lang.String;
      //class [[I
      //void
      //class java.lang.annotation.ElementType
      //interface java.lang.Override
      //class java.lang.Integer
    }
}

类初始化
1. 类的主动引用：
  - new
  - main()方法所在的类
  - 反射 Class.forName()
2. 被动引用不会初始化
  - 常量
  - 数组
  - 通过子类获得父类的静态字段，子类不初始化

类加载器

分类
- 引导类加载器 BootStap Classload
- 扩展类加载器 Extension Classload
- 系统类加载器 System Classload
- 自定义加载器

可以加载的路径

System.out.println(System.getProperty("java.class.path"));
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\charsets.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\deploy.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\access-bridge-32.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\cldrdata.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\dnsns.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\jaccess.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\jfxrt.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\localedata.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\nashorn.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\sunec.jar;
        // C:\Program Files(x86)\Java\jdk1.8.0_202\jre\lib\ext\sunjce_provider.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\sunmscapi.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\sunpkcs11.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\ext\zipfs.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\javaws.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\jce.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\jfr.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\jfxswt.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\jsse.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\management-agent.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\plugin.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\resources.jar;
        // C:\Program Files (x86)\Java\jdk1.8.0_202\jre\lib\rt.jar;
        // C:\Users\CSF\IdeaProjects\javaSE\out\production\javaSE;
        // D:\Program Files\JetBrains\IntelliJ IDEA 2019.3.2\lib\idea_rt.jar

setAccessible 私有属性，构造器，方法
获取泛型

获取注解

package com.csf.reflect;

import java.lang.annotation.*;

public class Demo5 {
    public static void main(String[] args) throws NoSuchFieldException {
        Class<Student> studentClass = Student.class;

        Annotation[] annotations = studentClass.getAnnotations();
        for (Annotation annotation: annotations){
            System.out.println(annotation);
        }

        Table table = studentClass.getAnnotation(Table.class);
        System.out.println(table.value());

        java.lang.reflect.Field id = studentClass.getDeclaredField("id");
        Field annotation = id.getAnnotation(Field.class);
        System.out.println(annotation.column());
        System.out.println(annotation.length());
        System.out.println(annotation.type());
    }
}

@Table("db_student")
class Student{
    @Field(column = "db_id", type = "int", length = 10)
    private int id;

    @Field(column = "db_age", type = "int", length = 10)
    private int age;

    @Field(column = "db_name", type = "varchar", length = 3)
    private String name;

    public Student(int id, int age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public Student() {
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", age=" + age +
                ", name='" + name + '\'' +
                '}';
    }


}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface Table{
    String value();
}

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface Field{
    String column();
    String type();
    int length();
}

多线程

main —主线程

线程创建

继承——Thread
实现——Runnable

实现——Callable

package com.csf.thread;

import java.util.concurrent.*;

public class Demo5 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //创建执行服务
        ExecutorService service = Executors.newFixedThreadPool(1);
        //提交执行
        Future<Boolean> future = service.submit(new ThreadTest3());
        //获取结果
        Boolean result = future.get();
        System.out.println(result);
        //关闭服务
        service.shutdownNow();
    }
}

class ThreadTest3 implements Callable<Boolean>{

    @Override
    public Boolean call() throws Exception {
        for(int i=0; i<100000;i++){

        }
        return true;
    }
}

线程同步问题

package com.csf.thread;

public class Demo4 implements Runnable {

    private int ticket = 10;

    public static void main(String[] args) {
        Demo4 ticket = new Demo4();
        new Thread(ticket, "小明").start();
        new Thread(ticket, "小红").start();
        new Thread(ticket, "小光").start();
    }

    @Override
    public void run() {
        while (true){
            if (ticket <= 0)
                break;
            System.out.println(Thread.currentThread().getName() + "==>拿到了第"+ (ticket--) + "张票");
        }
    }
}

//小红==>拿到了第10张票
//小光==>拿到了第9张票
//小明==>拿到了第10张票
//小光==>拿到了第7张票
//小红==>拿到了第8张票
//小光==>拿到了第5张票
//小明==>拿到了第6张票
//小红==>拿到了第4张票
//小光==>拿到了第3张票
//小明==>拿到了第2张票
//小红==>拿到了第1张票

静态代理模式

package com.csf.thread;

public class StaticProxy {
    public static void main(String[] args) {
//        Marry you = new You();
//        WeddingCompany weddingCompany = new WeddingCompany(you);
//        weddingCompany.happyMarry();
        new WeddingCompany(new You()).happyMarry();
        
        new Thread(()->{ System.out.println("love"); }).start();
    }
}

interface Marry{
    void happyMarry();
}

class You implements Marry{

    @Override
    public void happyMarry() {
        System.out.println("要结婚了了");
    }
}

class WeddingCompany implements Marry{

    private Marry target;

    public WeddingCompany(Marry target) {
        this.target = target;
    }

    @Override
    public void happyMarry() {
        before();
        target.happyMarry();
        after();
    }

    private void after() {
        System.out.println("收钱");
    }

    private void before() {
        System.out.println("布置现场");
    }
}

lambda表达式

函数式接口：只包含唯一一个抽象方法如Runnable接口

package com.csf.lambda;

public class Demo1 {

    static class Like2 implements ILike{

        @Override
        public void func() {
            System.out.println("love2");
        }
    }

    public static void main(String[] args) {
//      方式一：最原始的方法
        ILike way1 = new Like();
        way1.func();

//      方式二：静态内部类
        new Like2().func();

//      方式三：局部内部类
        class Like3 implements ILike{
            @Override
            public void func() {
                System.out.println("love3");
            }
        }
        new Like3().func();

//      方式四：匿名内部类
        ILike way4 = new ILike() {
            @Override
            public void func() {
                System.out.println("love4");
            }
        };
        way4.func();

//      方式五：lambda表达式
        ILike way5 = () -> {
            System.out.println("love lambda");
        };
        way5.func();

    }


}

interface ILike{
    void func();
}

class Like implements ILike{

    @Override
    public void func() {
        System.out.println("love");
    }
}

带参数的lambda

package com.csf.lambda;

public class Dmo2 {
    public static void main(String[] args) {
        ILove love = (a -> {
            System.out.println("I love " + a + " 元");
        });
        love.love(100);
    }
}

interface ILove{
    void love(int a);
}

线程状态
1. new
2. 就绪
3. 运行
4. 阻塞
5. 死亡
yield

join

package com.csf.thread;

public class TestJoin {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(new Join(), "Vip");
        t1.start();
        for (int i=0; i<1000; i++){
            if (i==300){
                t1.join();
            }
            System.out.println("main"+ i);
        }
    }
}

class Join implements Runnable{

    @Override
    public void run() {
        for (int i=0; i<1000; i++){
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

IDEA 快捷键：100.for ——for(int i=0; i<100; i++)
synchronized
CopyOnWriteArrayList
死锁
Lock
- ReentrantLock
生产者消费者
线程池
- ExecutorService
  - execute(Runnable)
  - submit(Callable)
- Executors--线程池的工具类，创建不同类型的线程池

javaSE

Java SE 笔记

数据类型

基本数据类型

数据类型转换

强制类型转换 （类型）变量名 高转低

自动类型转换 低转高

流程控制

Scanner

面向对象

异常

网络编程

注解

反射

多线程

强制类型转换（类型）变量名高转低

自动类型转换低转高