java基础复习

靡不有初 鲜克有终！

Java基础

JDK java develop kit java开发程序包

JRE java runtime environment java运行时环境

JVM Java virtual machine java虚拟机

.java 源代码文件

.class 字节码文件

.java -> javac编译 -》java 加载到-》jvm中执行

Java-》跨平台（不同的操作系统），依靠jvm实现（.class）

JAVA_HOME=jdk路径
Path=...%JAVA_HOME%\bin
验证
javac
java
java -version

public static void main(String[] args) {
   // java程序的主方法
}

数据类型

基本数据类型

byte short int long float double char boolean

1 2 4 8 4 8 2 1

0 0 0 0L 0.0 0.0 空 false

包装类

Byte Short Integer Long Float Double Character Boolean

默认值 null

类型转换

自动类型转换 0 int -> 0.0 double a = 0;

强制类型转换 0.0 double -> 0 int int a = (int)0.0;

运算符

+ - * /  %
++ --
>= <= == !=
&&  ||   !    短路操作
A ? B : C    a->true  B  否则 C

public static void main(){
   int a = 10;
   sout(a++);  //  10  sout(a)  a = a + 1
   sout(--a);  //  10  a = a - 1  sout(a) 
}

条件以及循环语句

switch(a) -case a的类型byte short int String enum

if - else .....

if - else if - else .....

while

do while -》 至少会执行一次

for

三个关键字

break

跳出所在循环，跳出switch语句

return

结束方法或返回值

public void test(){
    return;
}
public int test(){
    return 10;
}

continue

跳过本次循环，继续下一次循环

数组

数组的定义

int[] a = new int[4];// 4 代表长度
int[] b = {1,2,3,4}
a.length

二分查找 冒泡排序 快速排序

数组遍历

for循环
   for(int i = 0; i < a.length; i++){
       sout(a[i])
   }
foreach循环
   foreach(int value:a){
       sout(value)
   }

面向对象

万事万物皆对象 OOP 面向对象编程

类

public class People{
   属性  方法  构造器(与new一起使用，用于创建以及初始化对象)
}

命名规则 -》 类名所有的单词首字母全部大写

封装

public 公共的 任何地方

protected 同包 + 子类

默认（不写） 在同包下

private 私有 当前类中

继承

子类继承父类，单继承

子类拥有了父类的能力（子类拥有了父类的所有属性和方法），可以在父类的基础上扩展自己的属性与方法，构造器是不能被继承的，可以对父类的方法进行重写。

多态

父类引用/接口变量 指向具体的子类实例/实现类实例，当调用同名方法时，表现出不同的行为特征，多态

端午：放三天假 - 》学习

? -》 打游戏

? -》 旅游

this与super

this 在方法中或者说构造器中出现，代表当前创建的对象本身

super 父类对象，完成父类构造器的调用，属性的初始化

public class A(){
     private String name;
     public A(String name){
         this.name=name;
     }
     // ....getter setter
}
public class B extends A{
     private int age;
     
     public B(int age){
        this.age = age;
     }
     public B(String name, int age){
          //this.name=name;
          super(name);
         // ( this(age)  )
     }
     // ....getter setter
}

public static void main(String[] args) {
        B b = new B("B", 10);
        sout(b.getName())
}
A. B  B.编译出错  C.A

重载与重写

public void test(String a) {

}

重载：同类中，方法名相同，形参列表不同

重写：子类继承父类 方法名相同 形参列表相同 返回值相同

抽象类与接口

抽象类

未完成的类设计，体现的是一种模板

public abstract class Animal {
  普通方法
  抽象方法  
  public abstract String abs();
  构造器
  属性
}

获取了新的能力 ： 可以包含抽象方法

失去了一个能力 ： 创建对象，拥有实例 ，构造器用于属性初始化

接口

接口体现了设计与实现相分离，是一种行为规范，不能创建对象，没有实例

public interface IUserService{
     // public static final默认修饰 
     String INFO = "常量属性";
     // 都是抽象方法，默认使用public abstract 修饰
     void test();
     //  接口在1.8中可以添加默认事项
     default void info(){
     
     }
}

命名规则（优雅的代码）：方法名 类名 变量名

慢慢尝试方法的封装-》刻意的模仿与练习

设计模式

建造者模式

观察者模式

简单工厂模式/抽象工厂模式

集合

List

ArrayList根据下标获取对应位置的元素，有序可重复

for 循环 foreach 迭代器

集合中的方法：

? remove get iterator size add isEmpty

for(int i = 0; i < infoList.Size(); i++){
  sout(infoList.get(i));
}

LinkedList ArrayList Vector

Set

HashSet 无序不可重复

? foreach 迭代器

List<String> infoList = new ArrayList();
foreach(String s:infoList) {
    sout(s);
}

Iterator interator = infoList.iterator();
while(iterator.hasNext()){
  sout(iterator.next())
}

不可重复，如果需要将以下类的对象保存到Set中，需要做什么

public class People{
   private String name;
   private int age;
   
   // 重写equals 和 hashcode方法
}

equals返回true hashcode要相同，此时才认为两个对象是同一个对象

Map

HashMap

Map<String,String> map = new HashMap();
put(key,value)
.....
get(key)

两种方式遍历

Set<String> keySet = map.keySet();
foreach(String key:keySet){
     sout(key + "," + map.get(key))
}

Set<Entry<String,String>> set = map.entrySet();
foreach(Entry<String,String> keyValue:set){
     sout(keyValue.key() + keyValue.value())
}

HashTable ConcurrentHashMap 数据结构

单例类

懒汉式 饿汉式

• 构造器要私有
• 保证始终只有一个对象
• 提供一个公有的方法，被外界访问，提供这个对象

public class SingleInstance{
     private static SingleInstance singleInstance = null;
     private SingleInstance(){
     
     }
     
public static synchronized SingleInstance getInstance(){
           if(null == singleInstance) {
               singleInstance = new SingleInstance();
           }
           return singleInstance;
     }    
}

public static void main(String[] args) {
     SingleInstance  singleInstance =  SingleInstance.getInstance()
}

是线程安全的吗？如何这种情况下的线程安全？

public class SingleInstance{
    private static final SingleInstance SINGLE_INSTANCE = new SingleInstance();
    private SingleInstance(){
    
    }
    public static SingleInstance getInstance(){
        return SINGLE_INSTANCE;
    }
}

两种方式对比！ 重要 ！！！！！

泛型

JDK1.5开始引入，在定义时使用字母代替，在使用时指定具体类型

泛型类 泛型方法 --》认识

public class<T> People{
    T t;
    
    public <A> void test(A a){
    
    } 
}

不指定泛型，默认是Object类型

Object

当一个类没有显式的继承关系，则默认继承Object

Object equals 方法，默认实现等价于 ==

? hashcode

? wait 线程中 线程进入等待（同步锁 同步监视器）

? notify 线程中 唤醒调用过wait的某一个等待的资源

? notifyAll 线程中 唤醒调用过wait的所有等待的资源

Math

? abs max min floor ceil pow sqrt

Date&Calender

Date date = new Date();
System.currentTimeMillions();
date.getTime();

Date -》 Calender对象
// 获取年月日  时分秒

日期转化 2020/06/28 15:16:22 将系统的当前时间转化为此格式

Date date = new Date();
String dateStr = "2020/06/28  15:16:22";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
simpleDateFormat.format(date);  // 日期格式化为指定字符串
simpleDateFormat.parse(dateStr); // 日期字符串解析为日期类型，异常需要捕获处理

String

final修饰的类， 不可以被继承

equals 用于判断两个值是否相等，为什么可以？ 进行了重写 逐个字符进行比较

split subString indexOf lastIndexOf charAt replace trim length

final finally finalize

......

异常

Throwable Error - Exception

检查型异常

程序编译的的时候就会报出来的异常

FileNotFondException IOException SQLException

运行时异常 RuntimeException

? 程序在运行的过程中发生的异常，这种异常是程序员的错误，必须要修复

NullPointException ClassCastException ArrayIndexOutOfBoundsException

try{
  // 异常可能发生的代码
} catch(需要捕获的异常){ // 被获取异常的子类以及前当前类都可以被捕获
  // 捕获到异常时该怎么处理
} finally {
  // 不管是否发生异常，都会执行
}

throw与throws区别

// 抛出异常对象，交个调用者处理
public void test () throws FileNotFoundException {
   
}


public void test() throws Exception{
   try {
   } catch(Excepiton e){
      // 初步异常处理后，在主动抛出异常对象
      // throw new Exception();
       throw e;
   } finally {
   
   }
 
}

异常抛出流程

如果某方法抛出异常，如果该方法不处理，则该异常抛出给其调用者处理，依次类推，直到找到处理者为止，如果异常到达主方法（main），还没有对异常做出处理，主方法将异常抛给JVM处理，JVM处理就是结束当前程序。

自定义异常

现有异常无法满足我们工作中所遇到问题的错误描述，所以自定义异常，以此来对遇到的问题做出一个描述。

public class SelfException extends Excepiton{
    public SelfException(){

    }
  public SelfException(String message){
    this.message = message;
  }
}

String StringBuffer StringBuilder

String -》final 不可变类 不可以被继承， 字符串初始化之后，不允许改变，即“abc”在内存中不会发生变化

String a = "abc";
a = "123";

StringBuffer 可变的字符串，可以进行追加 插入 删除 替换 ......,就是在源字符串上进行变化

StringBuffer stringBuffer = new StringBuffer("aa");
stringBuffer.append("bb");

StringBuilder也是可变长度的字符串，方法跟StringBuffer基本一样，只不过StringBuffer 是线程安全的，StringBuilder是非线程安全的

线程

定义方式

• 继承Thread

  public class ThreadDemo extends Thread{
      public void run(){
        
      }
  }
  
  

  ThreadDemo thread = new ThreadDemo();
  thread.start();
  
  

• 实现Runnable

  public class RunnableDemo implements Runnable{
      public void run(){
      
      }
  }
  
  

  RunnableDemo runnable = new RunnableDemo();
  Thread thread = new Thread(runnable);
  thread.start();
  
  

  实现的时候，一般会优先选择Runnable接口的方式，因为继承是单继承的，实现可以多实现，使用接口方式，避免了继承的局限性，使用接口方式，我们还可以在继承其他类，以及实现其他接口。

线程与进程的关系

线程的生命周期

new 新建 -》 start() 就绪 -》获取CPU Running -》 运行结束 死亡

yield 方法 线程让步

暂停当前的线程，线程进入就绪状态，之后优先级相同或更高的线程开始竞争这个资源执行

sleep 线程休眠

线程调用sleep方法，会进入阻塞状态，在睡眠期间，不会释放同步锁，带睡眠时间结束后进入就绪状态

join 线程引入

另一个线程加入到当前线程，当前进入阻塞状态，待另外一个线程执行结束或者执行时间满足之后，当前线程进入就绪状态

wait 线程等待，进入阻塞状态，会释放同步锁，

notify 唤醒一个等待的线程

notifyAll 唤醒所有等待的线程

此三个方法，均由同步监视器（同步锁）来调用，等待与唤醒他们一定要是同一个同步锁

synchronized

线程同步synchronized （线程安全）

public synchronized  void test(){
 // this
}

public void test(){
   // 自己指定-》要求尽量选择多个线程共享的对象
  synchronized(this){
  
  }
}

public static synchronized void test(){
   // 当前的所在类  Demo.class   类对象
}

wait notify notifyAll

生产者与消费者的例子

死锁

Lock ReentenLock（了解）

线程池

基本概念 几种线程池特点

IO流

字节流（Stream） 字符流（Reader Writer）

输入流(从磁盘文件-》内存) 输出流（内存-》磁盘文件）

InputStream OutputStream Reader Writer

字节流

FileInputStream FileOutputStream

BufferedInputStream BufferedOutputStream

ObjectInputStream ObjectOutputStream 序列化 implements Serilizable接口

将对象序列化到磁盘， 从磁盘读取序列化数据转换为对象

对象数据在网络中传输，必须要序列化

字符流

FileReader FileWriter

BufferedReader BufferedWriter

转换流： 字节流转换为字符流

InputStreamReader OutputStreamWriter

static

静态的 - 静态变量 静态方法 加载顺序

注解

注解不是注释

@Override @Deprecated @SuppressWarnings

怎样声明注解

public @interface Anno{
  int age() default 0;
  String value();
}

修饰注解的 - 元注解

@Retention

保留策略：RUNTIME CLASS SOURCE

? 如果使用这个注解修饰注解定义，那么定义的那个注解在使用时，会保存到什么阶段

@Retention(.....Retention.RUNTIME)
public @interface Anno{

}

@Target

修饰一个注解，表示注解可以用于哪些内容

@Target(.....TARGET.TYPE,METHOD,FILED)
public @interface Anno{

}

@Document

注解会生成到Javadoc文档

反射

类的类 类对象

package com.cx;
public class Demo{
}

1.Class clz1 = Demo.class;
2.Class clz2 = Class.forName("com.cx.Demo");
3.Demo demo = new Demo();
  Class clz3 = demo.getClass();

通过类对象反射操作类：创建对象 调用方法 属性赋值

类的加载

加载 -》 连接(为静态属性赋初值) -》初始化

初始化阶段

初始化顺序依次是：（静态变量、静态初始化块，按顺序加载）–>（变量、初始化块 按顺序加载）–> 构造器

    public static String info = "name";
    static {
        System.out.println("static block");
        // info写到静态代码块的下面会报错
        System.out.println(info); 
    }

    public  String infoNormal = "name";
    {
        System.out.println("normal block");
        // infoNormal写到代码块的下面会报错
        System.out.println(infoNormal);
    }
    
    public static void test(){

    }
    public InitClass(){
        test();// 正常执行，不报错
    }

Lamda

基本语法

NIO（了解）

String判断真假（重要）

== ：比较的是内存地址值
equals： 比较的是值，对象的equals()可以被重写

java中字符串的比较：==

String a="abc";
String b="abc"

那么a==b将返回true。因为在java中字符串的值是不可改变的，相同的字符串在内存中只会存 一份，所以a和b指向的是同一个对象；

String a=new String("abc"); 
String b=new String("abc");

那么a==b将返回false，此时a和b指向不同的对象。

用equals方法比较的是字符串的内容是否相同

String a=new String("abc"); 
String b=new String("abc");

a.equals(b); 将返回true。

如果是

String s1 = “abc”;
String s2 = “a”;
String s3 = “bc”;
String s4 = s2 + s3;
System.out.println(s1 == s4);

false，因为s2+s3实际上是使用StringBuilder.append来完成，会生成不同的对象

而

String s1 = “abc”;
final String s2 = “a”;
final String s3 = “bc”;
String s4 = s2 + s3;
System.out.println(s1 == s4);

true，因为final变量在编译后会直接替换成对应的值，所以实际上等于s4=”a”+”bc”="abc"，而这种情况下，编译器会直接合并为s4=”abc”，所以最终s1==s4(就相当于第一种情况)。

int Integer

双向链表

String StringBuffer StringBuilder

内部类

类的内部或方法内部再定义其他类

public class OuerClass {
    // 使用实例访问
    public String name;
    // 静态变量  类变量   类名访问
    public static int age;
    // 属性 方法 构造器
    static class StaticInnerClass{
    }
    class InnerClass{
    }
    public static void main(String[] args) {
        
        String info = "info";
        
        OuerClass ouerClass = new OuerClass();
        // 实例.属性
        ouerClass.name = "dd";
       // 类名.静态属性
        OuerClass.age = 10;

        new OuerClass.StaticInnerClass();
        ouerClass.new InnerClass();
        
        // 局部内部类（方法内部） 仅在方法范围内有效
        class Info1{
            
        }

        Info1 info1 = new Info1();
    }
}

匿名内部类

public interface InnerInterface {
    String fun1();
}

public abstract class InnerAbstarct {
    public abstract int fun2();

    public String test(){
        return "info";
    }
}

public class InnerDemo {
    // 接口没有实例  接口可以new，但是这个new是创建接口实例？不是
    // new InnerInterface 创建了一个匿名内部类实例，这个内部类实现了InnerInterface接口
    // 适用于只需要创建一次的类
    static InnerInterface innerInterface = new InnerInterface(){
        // 实现接口的方法
        @Override
        public String fun1() {
            return "fun1";
        }
    };
    //  抽象类没有实例，体现的是一种模板 new InnerAbstarct，创建了一个匿名内部类实例
    // 这个匿名内部类继承了InnerAbstarct抽象类
    InnerAbstarct innerAbstarct = new InnerAbstarct() {
        @Override
        public int fun2() {
            return 0;
        }

        @Override
        public String test() {
            return "sub";
        }
    };

    OuerClass outerClass = new OuerClass();

    public static void main(String[] args) {
        innerInterface.fun1();
        InnerDemo innerDemo = new InnerDemo();
        innerDemo.innerAbstarct.fun2();
        innerDemo.innerAbstarct.test();

        // 方法内部的匿名内部类
        InnerInterface innerInter = new InnerInterface() {
            @Override
            public String fun1() {
                return null;
            }
        };

        innerInter.fun1();

    }
}

枚举类

/**
 * 数学：枚举法 可能的个数是有穷个可能，一次把他们列举出来
 * 枚举类
 * 枚举的是当前类有哪些实例，哪些元素/可能
 * <p>
 * 这个枚举类表示的是性别
 * 男 女
 * 枚举实例，实例也就是创建好了的，在之后使用不需要在进行创建
 * 创建对象，并为其属性初始化  new 构造器
 */
public enum EunmSexDemo {
    // public static final
    MALE("男", 22), FEMALE("女", 20);

    // 构造器私有，只能写private，或者不写
    EunmSexDemo(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

public class MainEnum {
    public static void main(String[] args) {

        System.out.println(EunmSexDemo.MALE.getAge());
        System.out.println(EunmSexDemo.FEMALE.getName());



        switch(EunmSexDemo.MALE){

        }
    }
}

java基础复习

原文：https://www.cnblogs.com/D-Hong/p/13216536.html