JavaEE学习小结(一)

封装

• 概念:隐藏实现细节,仅暴露公共的访问方式.(是一种思想)

• 好处:1.提高了代码的安全性

  ​ 2,提高了代码复用性

• 构造方法(构造器);

​ 执行时期: new对象是时候由系统自动执行,不能手动调用

​ 作用: 给成员变量初始

​ 注意: 若没有编写,系统自动给出一个默认空参构造

String

• 概念: 代表字符串,所有字符串文字都是此类的实例(“abc”)
• 特点: 不可改变,他们的值在创建后不能被更改
• 字符串常量池: String类有个常量池,jdk8之前在方法区,之后挪到了堆内存,双引号创建的对象,都会存放在常量池,若创建的对象已存在,则不再创建该对象,直接指向已存在对象的地址.
• 构造方法
  • public String();
  • public String(char[] arr); √
  • public String(byte[] bys);
  • String s = "abc" √
• 两种创建字符串的去区别
  • 构造方法创建,每次都会申请内存地址,内容相同,但地址不同.
  • String s1 = new String ("abc");
  • String s2 = new Sreing ("abc");
  • 直接赋值创建,内容相同,地址相同
    • String s1 = "abc";
    • String s2 = "abc";
• equals : 比较两个字符串内容是否相等
• == : 比较两个字符串地址是否相等

StrigngBuilder

• 概念 : 可变的字符串类,可以看出一个容器;

• 构造方法

  • public StringBuilder();
  • public StringBuilder(String s);

• 方法

  • public StringBuilder append(Object obj); //添加
  • public StringBuilder recerse(); //取反
  • public int lnegth(); //获取长度
  • public Strigng toString() //换换成String

• StringBuilder与Stirng相互转换

  • SB >>>> S toString();
  • S >>> SB 构造方法;public StringBuilder(s);

  ArrayList

• 集合: 提供一种存储空间可变的模型.存储容量可以发生改变

• 特点: 底层数组实现的,长度可以发生改变,查改快,增删慢

  • 增:当装不下的时候,就好自动扩容,先创建一个1.5倍的新数组,再将初始化的元素复制到新数组中,随后再将新元素添加到新数组中.
  • 删: 如果一个数组装满了1000个元素, 当我们将第一个元素删除掉之后, 后面的999个元素会整体的向前移动一位
  • 查询快, 修改快 : 数组有索引, 可以根据索引快速定位到要操作的这个元素.

• 泛型: 约束集合中存储元素的数据类型

• 构造方法: public ArrayList();

• 成员方法

  remove (删除指定元素/删除)… set … get… size… add…

继承

• 概念: 在一个已知类的基础上,创建一个新的类的过程.
• 格式: 子类名 extends 父类名{}
• 好处:
  • 子类可以直接访问父类非私有成员
  • 提高代码的复用性
  • 多态的前提
• 特点
  • 成员变量重名,就近原则,可用this和super区分
  • 成员方法重名,就近原则,可用super.方法名()调用父类方法
• 重写(overrode)
  • 重载(overlord)
  • 父类功能不足,就需要重写父类方法
  • 保证方法权限要大于父类方法权限,建议一样
  • 若分类方法被private修饰,则没有重写的说法
• 构造方法
  • 构造方法子类无法继承的,因为构造方法要与类名一致;
  • 子类的任意构造方法的第一行,默认有一句代码:super();调用父类无参构造方法;
• super和this
  • 父类空间优先于子类对象产生,因为子类构造首先调用的是父类构造
  • this指的是整个对象空间,优先访问自己的.没有才访问父类
  • super指的是继承父类的那个部分空间,只会访问父类继承空间
  • this(args) 调用子类自己的构造 super(args) 调用父类构造
• Java继承的特点
  • Java中只能支持单继承,不能支持多继承(一个孩子只有一个亲爹)
  • Java中支持多层继承(一个孩子只有一个亲爹,但是亲爹也可以有一个自己的亲爹)
  • Java中所有的类最终肯定会继承Object类

抽象类

• 概述
  • 抽象类: 含有抽象方法的类,abstract修饰
  • 抽象方法: 只有方法声明,没有方法实现(方法体);
• 使用
  • 抽象类不能创建对象,(因为没有方法实现,无意义)
  • 天生是当爹的
  • 被实现后必须重写所有抽象方法
  • 可有构造方法
  • 抽象类不一定有抽象方法,有抽象方法的类一定是抽象类

接口

• 概述: 接口是一种极端的抽象类,接口中不能有正常的方法

• 方法

  • public abstract 返回值类型 方法名 (参数); //抽象方法JDK1.7

  • public 返回值类型 方法名(参数){ //默认方法JDK1.8

    ​ 方法体;

    }

  • public static 返回值类型 方法名(参数){ //静态方法JDK1.8

    ​ 方法体;

    }

• 实现

  • 不能创建对象
  • 天生给其他类实现的

• 使用

  • 必须重写接口中所有的抽象方法
  • 选择性重写默认方法
  • 静态方法没有重写概念
  • 单继承,多实现

• 继承和实现的优先级

  • 父类接口抽象方法重名只需重写一次
  • 接口的默认方法重名,必须重写一次
  • 父类的正常方法和接口的默认方法重名不需要重写,优先调用父类正常方法

• 接口的多继承

  • 接口和接口是多继承的
  • 一个子接口可以继承多个父接口,一个实现类实现了这个子接口,相当于继承了多个父接口

• 接口的其他成员特点

  • 接口中不能定义普通成员变量,必须由public static final 修饰,(可省略不写)
  • 接口中没有构造方法,不能创建对象
  • 没有静态代码块

多态

• 前提
  • 必须有继承/实现关系
  • 必须有方法重写
• 体现
  • 父类 对象名 = new 子类();
• 调用方法的特点
  • 编译看父类
  • 运行看子类
  • 只能调用父类子类都用 的方法
• 好处
  • 提高了代码的维护性(继承保证)
  • 提高了代码的拓展性(多态保证)
• 弊端
  • 不能调用子类特有的方法
• 转型(解决弊端)
  • 自动转型(向上转型): 子转父
    Animal an = new Dog(); //多态!!!
  • 强制转型(向下转型): 父转子
    Animal an = new Dog(); //必须有向上转型的前提
    Dog dd = (Dog)an;
• instanceof关键字(运算符)
  • 判断一个对象是否属于某种类型
  • 格式: 对象名 instanceof 类名

修饰符

• final关键字
  • 修饰类: 不能被继承
  • 修饰方法: 不能被重写
  • 修饰局部变量-基本类型: 只能赋值一次,被称为常量,可以后赋值
  • 修饰引用类型变量: 只能赋值一次,可以后赋值,但必须写在构造方法内
• static关键字
  • 被修饰的成员属于类,而不是属于对象,通过类名直接调用
  • 修饰成员变量(称为静态变量,类变量),所有对象共享这同一个类变量,
  • 修饰成员方法(称为静态方法,类方法),方法本就是类的,不属于对象,对象只是保存了方法的引用地址,只是改变了调用方法
  • 静态不可以调用非静态(生命周期不同造成的)
    • 静态是随着类存在而存在
    • 非静态是随着对象存在而存在的
• 静态代码块
  • static{代码…}
  • 类中方法外
  • 不需要手动调用,JVM在第一次使用该类是,自动调用
  • 优先级高于构造方法,高于main方法
  • 用来做一些初始化操作,比如加载数据库驱动
  • 用来给静态成员赋值,比如给数据库连接四大要素赋值
• 权限修饰符
  • Java四大权限 public — protected —不写(default) — private

内部类

• 概念: A类中包含B类,A为外部类,B为内部类

• 成员内部类: 定义在类中方法外

  • 内部类创建对象格式:

    ​ 外部类名. 内部类名 对象名 = new 外部类名() . new 内部 类名();

• 局部内部类: 定义在类中方法中

• 内部类特点: 可以无条件的访问外部类中的任何成员.

• 匿名内部类: (语法糖) 创建抽象类的子类对象和接口实现类对象的简便格式

• 引用类型

  • 与基本类型的区别

    • 基本类型: 都在栈(Srack)中保存
    • 引用类型: 对象名存在栈中,真正的对象在堆(Heap)中保存

  • 基本类型可以做的引用类型也可以

  • 引用类型可作为方法参数返回值,

  • 引用类型也可做成员变量

    Weapon wq; //成员变量...Weapon武器类:有name,color,level,attack等成员变量.

    System.out.println( "拿着一把名字叫"+wq.name+",颜色为"+wq.color+",等级为"+wq.level+",攻击力为"+wq.attack+"的武器去砍人,一刀暴击99999");

Object类

• 简介: 所以类的超类,所以对象(包括数组)都拥有该类的方法

• 方法

  • public String toString(); …返回该对象的字符串表示

    • 默认格式; 包名.类名@地址值
    • 通常会重写该方法,让它返回对象内容,而不是地址值
    • 不需要自己调用,直接打印对象

  • public boolean equals(Object o); …比较两个对象是否相等

    • 默认比较: 地址值

    • 通常会重写比较两个对象的内容(属性值)

    • == 与 equals 的区别
      对于基本类型来说:
      == 比较是数值
      基本类型没有equals方法!!!
      对于引用类型来说:
      == 比较是地址值
      equals 默认比较也是地址值,如果重写了比较是对象属性值

时间日期类

• Date类

  • 构造方法:
    public Date();创建一个代表当前系统的时间的Date
    public Date(long time);创建一个代表距离标准时间time毫秒后的时间
    标准时间(英国):1970-01-01 00:00:00
    标准时间(中国):1970-01-01 08:00:00
  • 成员方法:
    public long getTime(); 获取Date对象距离标准时间的毫秒值
    public void setTime(long time);修改Date对象距离标准时间的毫秒值
    public String toString(); 重写Object的toString方法,返回时间字符串

• DateFormat时间/日期格式化类

  • 是一个抽象类,我们使用的是一个子类

  • simpleDateFormat类

    • 构造方法

      public SimpleDateFormat(String pattern);

    ​ //以指定的模板创建日期格式化对象
    ​ y - 年
    ​ M - 月
    ​ d - 日
    ​ H - 时
    ​ m - 分
    ​ s - 秒

    • 成员方法:
      public String format(Date date);将Date对象格式化为一个符合模板的时间串
      public Date parse(String time); 将符合模板的时间串解析为一个Date对象`

• Calendar类

  • 获取方式
    public static Calendar getInstance();
//静态方法,获取代表当前系统时间的日历对象
  • 常用方法
public int get(int field);根据字段的编号,获取该字段的值
public void set(int field,int value);根据字段的编号,修改字段的值
public void add(int field,int value);根据字段的编号,增加字段的值
public Date getTime();把Calendar对象转成Date对象

Math类

• Math中包含了很多数学运算相关的方法,而且这些方法都是静态的!!!类名直接调用即可

  ​ public static double abs(double d);求绝对值

  ​ public static double max(double d1,double d2);求最大值
  ​ public static double min(double d1,double d2);求最小值

  ​ public static double ceil(double d);向上取整(不是四舍五入)
  ​ public static double floor(double d);向下取整(不是四舍五入)

  ​ public static long round(double d);四舍五入
  ​ public static double random();产生一个[0,1)的随机小数

  ​ public static double pow(double d1,double d2);求次方

System类

​ 1.两个常用的静态方法
​ public static void exit(0);退出JVM虚拟机
​ public static long currentTimeMillis();获取当前系统时间距离标准时间的毫秒值,(用于计算某个代码块的运行时间)

包装类

• 包装类的介绍

  ​ :基本数据类型 对应的引用类型
  ​ byte Byte
  ​ short Short
  ​ char Character
  ​ int Integer
  ​ long Long
  ​ float Float
  ​ double Double
  ​ boolean Boolean
  ​

• Integer的构造和静态方法
  构造方法
  Integer i = new Integer(int value);
  Integer i = new Integer(String value);

    静态方法
    	Integer i = Integer.valueof(int value);
    	Integer i = Integer.valueof(String value);
  

• 自动拆箱和自动装箱的介绍

  • 自动拆箱: 把包装类 转成对应的基本类型
    在JDK1.7以前,只有手动拆箱
    Integer i = new Integer(10);
    int j = i**.intValue**();
    在JDK1.7,引入自动拆箱
    Integer i = new Integer(10);
    int j = i;//自动拆箱

  • 自动装箱: 把基本类型 转成对应的包装类
    在JDK1.7以前,只有手动装箱
    Integer i = new Integer(10);
    Integer i = Integer.valueof(10);
    在JDK1.7,引入自动装箱
    Integer i = 10;//底层 是通过静态方法执行

  • 总结:JDK1.7以后,基本类型和包装类类型我们可以当做基本处理

异常

• 异常
  1.什么是异常
  代码执行过程中出现的问题
  ArrayIndexOutputBoundsException
  NullPointerException
  2.异常的继承体系
  Throwable 异常的根类
  |- Error 错误类
  |- Exception 异常类
  |- 编译时异常 Exception类以及其子类(RuntimeException除外)
  |- 运行时异常 RuntimeException以及其子类
  3.异常类中常用的三个方法
  public void **printStackTrace();**打印异常的详细信息(包括异常类型,异常原因,异常位置)
  public String getMessage();获取异常的原因
  public String toString();返回异常的类型和异常的信息

​ 4.异常的分类
​ i.编译时异常
​ Exception类以及其子类(RuntimeException除外)
​ 编译时异常,会在编译时报错!!!

​ ii.运行时异常
​ RuntimeException以及其子类
​ 运行时异常,编译器不错报,直到运行时才报错!!

• 异常处理

​ 1.模拟JVM抛出异常(关键字throw)
​ throw:表示抛出一个异常对象
​ 格式:
​ throw 异常对象;

​ 2.Objects类中提供的非空判断方法
​ Objects类是一个工具类,所有的方法都是静态的
​ public static T requireNonNull(T t){

​ if(t == null){

​ throw new NullPointerException();

​ }

​ return t;

​ }`

​ 3.遇到异常的2种处理方式

​ ①throws声明抛出异常

​ 第一种处理方式:不处理,再次声明抛出

​ ②try…catch捕获异常

​ 第二种处理方式:捕获处理,把异常对象抓住**

​

​ 4.[扩展1]catch代码块中三种常见的处理方式

​ a.在开发阶段: 直接打印到控制台

​ b.在测试阶段: 写到日志文件中或者数据库中

​ c.在上线阶段: 先保存到本地,在适当的时机上传到服务器

​ 5.[扩展2]多个异常如何获取处理

​ method01(); 可能抛出OneException

​ method02(); 可能抛出TwoException

​ method03(); 可能抛出ThreeException

​ 6.finally代码块

​ finally被称为必须要执行的代码块

​ 格式:

​ try{

​ 可能出现异常的代码

​ }catch(XxxException e){

​ 处理异常

​ }finally{

​ 必须要执行的代码

​ }

​ 必须要执行的代码是指释放资源的代码

​ 比如:关闭文件的IO流,关闭数据库连接,关闭网络连接

​ 7.异常的注意事项

​ a.运行时异常,在编译阶段不需要声明也不需要捕获

​ b.父类的方法抛出多个异常,子类在重写该方法只能抛出这些异常的子集

​ c.如果父类的方法没有抛出异常,子类重写该方法时必须也不能抛出异常
​ d.如果有多个catch,那么必须先catch子类异常,再catch父类异常

​ e.trycatch后面可以finally,一般用于回收资源

​ f.多个异常如何捕获处理

​ i.每个异常单独trycatch

​ ii.多个异常一个try一个catch

​ iii.多个异常一个try多个catch

​ 总结:

​ a.如果写代码过程中,没有异常,就当做没学一样

​ b.如果遇到编译时异常,要么throws要么trycatch

​ c.如果遇到运行时异常,运行时程序崩溃了根据异常信息修改代码

• 自定义异常

​ 1.为什么要定义异常

​ 因为JDK所定义的异常类不可能描述所有问题,所以需要自定义异常

​ 2**.自定义异常的步骤**

​ a.创建一个异常类,该类必须叫做XxxException

​ b.该类必须继承Exception或者RuntimeException

​ c.自定义异常类至少提供两个构造

​ i.空参构造

​ ii.带有异常信息的String参数构造

多线程

• 并行和并发

​ 并行: 两个事件同一时刻都在进行

​ 并发: 两个事件同一时间段内存都在进行

• 进程和线程

​ 进程: 在内存中正在运行的程序

​ 线程: 进程中完成某个特定功能的执行单元

​ 进程和线程的一些区别(了解)

​ a.一个进程中可能包含多个线程,这种有多个线程的进程,我们称为多线程进程

​ b.进程用户独立的栈和独立堆

​ c.线程也拥有独立的栈,但是线程共享进程的堆

​ 线程调度

​ 常识: 一个单核的CPU,在同一时刻只能执行一条线程

​ 线程调度: CPU在多个线程之间进行快速切换

​ 线程调度分类:

​ 分时调度: 每个线程拼接分配CPU的时间

​ 抢占式调度: 每个线程随机分配CPU的时间

​ Java进程中多个线程采用抢占式调度

• 创建新的线程方式一

​ 当我们运行一个Java程序时,就是一个Java进程

​ 这个进程中默认有至少两个线程:

​ 第一个:main方法所在的线程,称为主线程

​ 第二个:GC线程

​ 如何创建一个新的线程呢???

​ Java中提供一个代表线程的类,称为Thread类

​ API的描述:

​ 一种方法是将类声明为 Thread 的子类。

​ 该子类应重写 Thread 类的 run 方法。

​ 接下来可以分配并启动该子类的实例

​ a.定义一个类继承Thread

​ b.重写run方法(就是写线程任务代码的地方)

​ c.创建子类对象(就是一个线程对象)

​ d.启动线程(调用start方法即可)