Java基础知识快速盘点(三)

一，构造器

• 创建一个类的方法时会调用该类的构造器

• 构造器，也叫构造方法

• 构造器是属于类的，对象不可调用

• 构造方法没有返回值类型

• 构造方法一般用public修饰，也可用private修饰，例如

public class Test {
	private Test() {    // 这个构造器外部无法调用
		super();
	}

	public static Test getTest() {
		return new Test();
	}
}

• 如果用户没有定义构造器，创建类的对象时会调用默认的无参构造器，用户定义构造器后，创建类的对象时会调用用户定义的构造器

• public class A {
                          
  }
                          
  class B {
  	public static void main(String[] args) {
          // new关键字会在堆区开辟出一块内存空间用于存放真正的对象
          // 对象创建完成后会返回一个该类的引用赋值给该类的引用变量
  		A a = new A();
  	}
  }
  

• 成员变量：位于内存中的堆区

• 局部变量：位于内存中的栈区

• 当局部变量名和成员变量名相同时，采取就近原则

二，方法重载

• 方法重载出现在同一个类中
• 方法名相同，参数列表不同，其他不做限制，这种现象就叫方法重载
• 构造器也可以进行方法重载，构造器也是方法

三，static关键字

• static可以用来修饰属性，方法（构造器除外），代码块，类（静态内部类）

• 静态成员存放在内存中的静态区，静态区的内容会随类的加载加载到内存

• 静态成员只有当类被卸载的时候随类的卸载而退出内存

• 静态成员不能访问类中的非静态成员

• static修饰属性（静态属性）

  • static修饰的属性属于类本身
  • static修饰的属性推荐的访问方式为：类名.静态属性
  • 一般不建议使用构造器对静态属性进行初始化

• static修饰方法（静态方法）

  • 推荐访问方式：类名.静态方法

• static修饰代码块（静态代码块）

  • 静态代码块会在类加载的时候自动执行

  • 静态代码块，匿名代码块，构造器执行顺序

  • 静态代码块（只执行一次） -> 匿名代码块 ->构造器

  • 静态代码块只会执行一次，因为类只会加载一次

  • jvm加载字节码文件会先从有main方法的文件加载

  • public class Test {
    	static {
    		System.out.println("静态代码块");
    	}
    	                                                
        // 匿名代码块会在构造器之前执行
    	{
    		System.out.println("匿名代码块");
    	}
    	                                                
    	public Test() {
    		System.out.println("构造器");
    	}
    	                                                
    	public static void main(String[] args) {
    		new Test();
            System.out.println("------------------");
            new Test();
    	}
    }
    
    
    /*******执行结果**************
    静态代码块
    匿名代码块
    构造器
    ------------------
    匿名代码块
    构造器
    */
    

四，封装

• 属性封装

  • 使用private修饰，提供公共访问方法

• 方法封装

  • 将冗余的代码或功能重复的代码封装为一个方法

• 类

  • 类本身就是一种封装

五，继承

• class 子类 extends 父类 {
  	                        
  }
  

• 父类当中的私有属性子类不可直接访问

• 在创建子类的对象时，会先去调用父类的无参构造器，然后再调用子类的构造器

• 若父类中没有无参构造器，子类在创建对象时若用户没有主动调用父类的构造器，程序将编译报错，因为在父类中找不到相应的无参构造器；

  class A {
      private int i;
      public A(int i) {
          this.i = i;
      }
  }
  
  public class B extends A {
      // 该静态代码块不会执行，因为文件无法通过编译
      static  {
          System.out.println("m");
      }
  
      public static void main(String[] args) {
          new B();    // 编译报错，父类中找不到相应的无参构造器
      }
  }
  

• 结合静态代码块和匿名代码块

  class A {
      static {
          System.out.println("A static");
      }
      {
          System.out.println("A 匿名");
      }
      public A() {
          System.out.println("A");
      }
  }
  public class Main extends A {
      public Main() {
          System.out.println("Main");
      }
  
      static {
          System.out.println("Main static");
      }
  
      {
          System.out.println("Main 匿名");
      }
      public static void main(String[] args) {
          new Main();
          System.out.println("-----------------------");
          new Main();
      }
  }
  
  /********运行结果************
  A static
  Main static
  A 匿名
  A
  Main 匿名
  Main
  -----------------------
  A 匿名
  A
  Main 匿名
  Main
  */
  

• this 和 super

  • this代表当前对象的引用
  • super代表本类当前对象的父类内存空间标识
  • this可以调用本类的成员变量，也可以调用父类的成员变量
  • super调用父类的成员变量
  • this调用本类构造器
  • super调用父类构造器
  • this可以调用本类的方法，也可调用父类的方法
  • super调用父类的方法

六，方法重写

• 方法名，参数列表与父类中要重写的方法相同
• 修饰符可以扩大，不可缩小
• 抛出异常不可扩大
• 返回值可以不同，但返回值类型必须相同

七，多态

• 多态的条件

  • 子类继承父类
  • 子类重写父类的方法
  • 父类的引用指向子类的对象

• 在多态的情况下，父类的引用只能访问到父类成员，无法访问到子类的成员

• 向上转型：父类的引用指向子类对象

• 向下转型：将父类的对象转换为子类的对象

• final

  • final修饰的类不能被继承
  • final修饰的方法不可被重写
  • 修饰变量，变量不可被更改，只能被赋值一次

• instanceof

  • 判断引用是否真正指向内存空间是否为该类型

八，抽象

• abstract可以修饰类，构成抽象类
• abstract修饰方法，构成抽象方法
• 抽象方法中可以没有实现
• 子类继承抽象类，子类必须重写或继续使用abstract修饰

九，接口

interface

• 声明一个接口使用interface关键字
• 接口中有相应的属性和方法
• 接口中的属性是公共的静态常量
• 接口中的方法默认是公共的抽象方法

关系对比

• 类与类

  • 继承，单继承

• 类与接口

  • 实现，单实现，多实现

• 接口与接口

  • 继承，单继承，多继承

接口中没有构造方法，接口的引用指向实现类的对象

十，内部类

分类

• 成员内部类
  • 作为一个成员存在
  • 不可以定义静态属性和方法
  • 访问外部类
    • 非静态属性，方法外部类名.this.属性（方法），静态属性，方法外部类名.属性（方法）
  • 外部类访问内部类
    • 创建内部类对象进行访问
• 静态内部类
  • static修饰成员内部类
  • 可以定义静态属性和方法
  • 访问外部类
    • 静态属性，方法外部类名.属性（方法）
  • 外部类访问内部类
    • 静态属性内部类名.属性
    • 非静态属性创建对象访问
• 局部内部类
  • 在方法中定义的内部类
  • 访问外部类
    • 非静态属性，方法外部类名.this.属性（方法），静态属性，方法外部类名.属性（方法）
  • 外部类访问内部类
    • 只能在方法内部访问
• 匿名内部类

十一，集合

• 集合与数组的区别
  • 集合长度不固定，数组长度固定
  • 只能存放引用类型，数组可存放引用类型，也可存放基本类型
• 集合继承体系
  • Collection 单列集合
    • List （有序，可重复）
      • ArrayList
        • 底层实现为数组
        • 查询修改快
        • 增删慢
      • LinkedList
        • 底层实现为链表
        • 查询修改慢
        • 增删快
      • Vector
        • 底层实现为数组
        • 相比于ArrayList，Vector是线程安全的，但效率低于ArrayList
    • Set （不可重复）
      • 元素不重复的保证：先调用hashCode方法，hash值相同调用equals方法
      • HashSet
        • hashCode()方法： hash值相同，对象不一定相同，hash值不同，对象一定不同
      • TreeSet
        • TreeSet会将数据进行排序
          • 自然排序（包装类实现了Comparable接口），对于自定义类也可以实现Comparable接口
          • 比较器（Comparator）实现其中的compare方法，然后将比较器传入TreeSet的构造器
    • Queue
  • Map （k, v）双列集合
    • Key值不可重复
    • HashMap
      • jdk1.8之前 数组+链表
      • jdk1.8之后 数组+红黑树（阈值8）
    • HashTable
    • TreeMap
      • 仅仅支持Key值排序
    • LinkedHashMap（双向链表）
      • 保证存取顺序一致
• 集合工具类
  • java.util.Collections

十二，泛型

类型参数化

• 泛型类

  • 例如：

    class Person<T> {
    	T age;
    	String name;
    }
    

  • 泛型相当于一个模板

  • 实例化对象

    类名<确定的类型> 变量 = new 类名<>();
    

  • 泛型的类型必须最终确定

• 泛型接口

  • 例如：

    interface Test<T> {
                    
    }
    

• 泛型方法

  • 例如：

    public <T> T test(T t) {
                    
    }
    

• 通配符：？

十三，IO流

Java程序：流

体系：

• 字节输入/输出流
  • 字节输入流
    • read()读取一个字节，返回该字节
    • read(byte[] b) 读取多个字节，返回读取到的字节数
    • read(byte[] b, int off, int length)
  • 字节输出流
    • write(int b)
    • write(byte[] b)
    • write(byte[] b, int off, int length)
• 字符输入/输出流
  • 字符输入流
    • read()读取一个字符，返回字符编码值
    • read(char[] c)读取多个字符，返回字符数
    • read(char[] c, int off, int length)
  • 字符输出流
    • write(int c)
    • write(char[] c)
    • write(char[] c, int off, int length)
• 包装流（方便操作数据）
  • 数据流
    • 方便操作基本类型及String
    • 构造器传入（InputStraem/OutputStream）
    • DataInputStream/DataOutputStream
    • 读写顺序保持一致
  • 缓冲流
    • 增加了一个缓冲区
    • BufferedInputStream/BufferedOutputStream
    • BufferedReader/BufferedWriter
  • 转换流
    • InputStreamReader/OutputStreamWriter
  • 对象流
    • 实现Serializable接口
    • 操作Java对象
    • 隐藏属性：transient关键字
    • 序列版本号：serialVersionUID
  • 随机访问流
    • RandomAccessFile
    • 单独的流
    • 可以从文件中的任意位置开始访问文件

步骤：声明流 -> 创建流 -> 使用流 -> 关闭流

十四，线程

• jvm线程调度策略属于抢占式调度

• 执行Java程序时，jvm会开辟一个main线程，对应于main方法

• java.lang.Thread 是java中的线程类，所有的线程对象都必须是Thread类或其子类的实例

• Java中通过继承Thread类来创建并启动一个新的线程的步骤如下：

  • 定义 Thread 类的子类（可以是匿名内部类），并重写 Thread 类中的 run 方法， run 方法中的代码就是线程的执行任务
  • 创建 Thread 子类的对象，这个对象就代表了一个要独立运行的新线程
  • 调用线程对象的 start 方法来启动该线程

• 给一个线程对象指定要执行的任务，除了继承Thread类后重写run方法之外，还可以利用Runnable接口来完成线程任务的指定

• java.lang.Runnable ，该接口中只有一个抽象方法 run，Thread属于Runnable的实现类

• Java中，线程可以分为：

  • 前台线程，又叫做执行线程、用户线程
  • 后台线程，又叫做守护线程、精灵线程

• 线程优先级

  • 优先级范围：1~10
  • 高优先级有更高概率抢占资源

• 线程组

  • Java中使用 java.lang.ThreadGroup 类来表示线程组，它可以对一批线程进行管理，对线程组进行操作，同时也会对线程组里面的这一批线程操作

• 线程状态

线程状态	名称	描述
NEW	新建	线程刚被创建，还没调用start方法，或者刚刚调用了start方法，调用start方法不一定"立即"改变线程状态，中间可能需要一些步骤才完成一个线程的启动。
RUNNABLE	可运行	start方法调用结束,线程由NEW变成RUNNABLE，线程存活着，并尝试抢占CPU资源，或者已经抢占到CPU资源正在运行，这俩种情况的状态都显示为RUNNABLE
BLOCKED	锁阻塞	线程A和线程B都要执行方法test，而且方法test被加了锁，线程A先拿到了锁去执行test方法，线程B这时候需要等待线程A把锁释放。这时候线程B就是处理BLOCKED
WAITING	无限期等待	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒
TIMED_WAITING	有限期等待	和WAITING状态类似，但是有一个时间期限，时间到了，自己也会主动醒来
TERMINATED	终止（死亡）	run方法执行结束的线程处于这种状态。

• sleep方法

  • 该方法可以使当前执行的线程暂时休眠指定毫秒数

• join方法

  • 可以让当前线程阻塞，等待另一个指定的线程运行结束后，当前线程才可继续运行

• interrupt方法

  • 该方法会打断阻塞状态，使对象抛出InterruptedException异常

• 线程同步

  • Java中实现线程同步的方式，是给需要同步的代码进行 synchronized 关键字加锁。
  • 产生线程安全问题的三要素
    • 多线程
    • 访问同一变量
    • 写入操作
  • synchronized 直接修饰一个方法，表示这个方法中的所有代码都需要线程同步，非静态方法锁对象为当前对象

• wait和notify

  • Object类中有三个方法： wait()、notify()、notifyAll()
  • 当一个对象，在线程同步的代码中，充当锁对象的时候，在 synchronized 同步的代块中，就可以调用这个锁对象的这三个方法
  • 三个核心点：
    • 任何对象中都一定有这三个方法
    • 只有对象作为锁对象的时候，才可以调用
    • 只有在同步的代码块中，才可以调用

• 死锁问题

  • 简单来说：线程t1和t2，t1拿着t2需要等待的锁不释放，而t2又拿着t1需要等待的锁不释放，俩个线程就这样一直僵持下去
  • 在程序中要尽量避免出现死锁情况，一旦发生那么只能手动停止JVM的运行，然后查找并修改产生死锁的问题代码

十五，网络编程

• 客户端
  • Socket(ip, port)
  • getInputStream
  • getOutputStream
• 服务器
  • Socket = serverSocket(port).accept()
• URL/URI
  • url 统一资源定位符
  • uri 统一资源标识符