JAVA基础学习总结

1.JAVA学习内容

JDK,JRE,JVM

• JDK：Java开发工具包
• JRE：Java运行时环境
• JVM：JAVA虚拟机

1.1 数据类型

• 基本数据类型
  • 数值型
    • 整数类型：byte（1字节）、short（2字节）、int（4字节）、long（8字节）
    • 浮点类型：float（4字节）、double（8字节）
  • 字符型：char（2字节）
  • 布尔型：boolean
• 引用数据类型
  • 类
  • 接口
  • 数组

1.2 变量

• 局部变量：在方法内部定义的函数
• 实例变量（成员变量）：在类定义
• 常量：大写字母加下划线

1.3 运算符

• 位运算符
  • ~：取反
  • &： 按位与
  • |： 按位或
  • ^： 按位异或
  • <<： 左移一位相当于除2取商
  • >>： 右移一位相当于乘以2

1.4 循环

• do while：先执行，后判断
• while：先判断，后执行
• for：先初始化计数器，然后，在每次循环前检测循环条件，在每次循环后更新计数器
• break：跳出循环
• continue：提前结束本次循环

1.5 面向对象

1.5.1 三大基本特征

• 封装
• 继承：单继承，可以安全向上转型
• 多态：Java的方法调用总是作用于运行期对象的实际类型，这种行为称为多态。

1.5.2 概念

• 面向对象编程的本质：以类的方式组织代码，以对象的方式组织数据

• 对象：是具体的事物

• 类：是对对象的抽象

• 先有具体的对象，然后抽象各个对象之间的部分，归纳出类，通过类再认识其他对象

1.5.3 内存分析

• 栈：连续的存储空间、存放局部变量
• 堆：不连续的存储空间、存放new出来的对象
  • 方法区：类的信息、static变量、常量池等

1.5.4 垃圾回收

对象创建分配空间：使用new

对象空间的释放：将对象赋值为null，通过System.gc();

1.5.5 重载

• 方法名称相同，但接受参数不同
• 同一个类，同一个方法名
• 不同：参数列表不同（类型、个数、顺序不同）
• 只有形参的名称不同，不构成方法的重载
• 返回值不同，不构成重载

class Hello {
    public void hello() {
        System.out.println("Hello, world!");
    }

    public void hello(String name) {
        System.out.println("Hello, " + name + "!");
    }

    public void hello(String name, int age) {
        if (age < 18) {
            System.out.println("Hi, " + name + "!");
        } else {
            System.out.println("Hello, " + name + "!");
        }
    }
}

1.5.6 继承

类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模

提高代码的复用性

子类是对父类的拓展

方法重写

子类对父类继承的方法重写

重写方法必须和被重写的方法具有相同的方法名称、参数列表和返回类型

重写方法不能使用比被重写方法更严格的访问权限

构造方法

默认在子类构造方法第一行实现父类构造方法，即super()

class Person {
    private String name;
    private int age;

    public String getName() {...}
    public void setName(String name) {...}
    public int getAge() {...}
    public void setAge(int age) {...}
}

class Student extends Person {
    // 不要重复name和age字段/方法,
    // 只需要定义新增score字段/方法:
    private int score;

    public int getScore() { … }
    public void setScore(int score) { … }
}

1.5.7 final 关键字

• 修饰变量：变量不可改变
• 修饰方法：方法不可被子类重写，但是可以重载
• 修饰类：不能有子类，不能被继承

1.5.8 封装

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可拓展性、可维护性。

	同一个类	同一个包	子类	所有类
private	*
default	*	*
protected	*	*	*
public	*	*	*	*

1.5.9 多态

• 程序的最终状态只有在执行程序过程中才被决定，而非编译期间
• 多态引用变量两种类型
  • 编译类型：一般是一个父类
  • 运行时类型：具体的子类
• 多态的必要条件
  • 继承
  • 方法重写
  • 父类引用指向子类对象

public class Main {
    public static void main(String[] args) {
        Person p = new Student();
        p.run(); 
    }
}

class Person {
    public void run() {
        System.out.println("Person.run");
    }
}

class Student extends Person {
    @Override
    public void run() {
        System.out.println("Student.run");
    }
}

1.5.10 抽象类

• 有抽象方法的类只能定义为抽象类
• 抽象类不能被实例化，即不能用new类实例化抽象类
• 抽象类可以包含属性、方法、构造方法。但是构造方法只能被子类调用
• 抽象类只能用来继承
• 抽象方法必须被子类实现

1.5.11 接口

接口是比抽象类还抽象的抽象类。全面专业地实现了规范和具体的分离

• 子类通过implements来实现接口中的规范
• 接口不能创建实例、但是可以声明引用变量的类型
• 一个类实现了接口就必须实现接口的所有方法，并且这些方法只能是public的
• 接口支持多继承

1.5.12 数组

• 数组是相同类型的有序集合
• 数组是对象，数组元素相当于对象的成员变量
• 数组长度是确定的，不可改变。

1.5.13 自动装箱和自动拆箱

• 自动装箱：
  • 基本类型自动封装到与它类型相同的包装中
• 自动拆箱：
  • 包装类对象自动转换成基本数据类型

1.5.14 Date

• Date

• SimpleDateFormat

  • format：将时间对象按照格式化字符串转换成字符串
  • parse：将字符串按照格式化字符串转换成时间对象

  public static void main(String[] args) {
  	Date date = new Date();
      System.out.println(date);
      String date1 = "";
      SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("yyyy-MM-dd");
      SimpleDateFormat simpleDateFormat3 = new SimpleDateFormat("yyyy/MM/dd");
      System.out.println(date1 = simpleDateFormat1.format(date)); 
      System.out.println(simpleDateFormat1.format(date));
      System.out.println(simpleDateFormat3.format(date));
      try {
          SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd HH:mm");
      	Date date2 = simpleDateFormat1.parse(date1);
  		System.out.println(date2);
      } catch (ParseException e) {
  		e.printStackTrace();
      }
  }
  

1.5.15 可变字符序列

• StringBuilder：线程不安全，效率高
• StringBuffer：线程安全，效率低

1.6 异常

                     ┌───────────┐
                     │  Object   │
                     └───────────┘
                           ▲
                           │
                     ┌───────────┐
                     │ Throwable │
                     └───────────┘
                           ▲
                 ┌─────────┴─────────┐
                 │                   │
           ┌───────────┐       ┌───────────┐
           │   Error   │       │ Exception │
           └───────────┘       └───────────┘
                 ▲                   ▲
         ┌───────┘              ┌────┴──────────┐
         │                      │               │
┌─────────────────┐    ┌─────────────────┐┌───────────┐
│OutOfMemoryError │... │RuntimeException ││IOException│...
└─────────────────┘    └─────────────────┘└───────────┘
                                ▲
                    ┌───────────┴─────────────┐
                    │                         │
         ┌─────────────────────┐ ┌─────────────────────────┐
         │NullPointerException │ │IllegalArgumentException │...
         └─────────────────────┘ └─────────────────────────┘

1.6.1 异常分类

• RuntimeException及其子类
• 非RuntimeException比如IOException
• 其中不需要捕获的异常：Error及其子类、RuntimeException及其子类
• 需要捕获的异常：IOException… …

1.6.2 异常说明

• Error异常
  • OutOfMemoryError：内存耗尽
  • NoClassDefFoundError：无法加载某个Class
  • StackOverflowError：栈溢出
• Exception
  • NumberFormatException：数值类型的格式错误
  • FileNotFoundException：未找到文件
  • SocketException：读取网络失败

1.6.3 异常捕获

• 使用多个catch语句捕获：可以从上到下匹配异常
• finally语句：无论是否捕获异常都会执行