日期相关

Date类

1.通常使用的是java.util包
2.导包 拿来使用 构建对象
3.通常使用的是无参构造方法 或者带long构造方法
4.Date类中常用的方法
     before();after();
     setTime();getTime();
     compareTo();
5.可以处理一个Date日期的格式

DateFormat类

1.java.text包 需要导包
2.此类是一个抽象类 不能创建对象 子类来使用
3.SimpleDarteFormat类 是DateFormat的子类
4.调用String参数的构造方法创建format对象
       SimpleDateFormat sdf =  new Simple DateFormat("yyyyy--MM--dd HH:mm:ss") 
       string v = sdf.format(date.1)//通过sdf将对象格式化成你描述的样子

Calendar 1.1版本

1.所属的包 java.util 需要导包
2.有构造方法 用protected修饰的 通常访问不到 通常还会调用默认的getInstance()
3.常用方法
        after() before()
        setTime() getTime()--->Date
        getTimeInMills()----time
        getTimeZone()----TimeZone
        Calendar calendar = Calendar.getInstance();//系统当前时间的Calendar对象
        Calendar里面包含一个date属性 可以操作某一个局部信息
        set get
        calendar.set（Calendar.YEAR,2015）;
        int year = calendar.get（Calendar.YEAR）;

TimeZone

1.java.util包
2.可以通过calendar对象.getTimeZone（）获取 或 TimeZone.getDefault();
3.常用方法 
       tz.getID();
       System.out.println(tz.getDisplayName());

java中提供的工具类——-官方API帮助文档

Application  Programming interface
应用程序编程接口,一些预先创建好的类及方法，目的是为了让我们更好的进行程序开发

与数学相关的类—-Math类

1.所属的包java.lang
2.Math构造方法是私有的 我们不能直接调用创建对象
3.由于Math中提供的属性方法都是static 不需要创建对象
4.常用的方法
           abs()返回给定数字的绝对值 （参数 int long float double）
           double = ceil() 向上取整
           double = floor()向下取整
           double = rint() 临近的整数 如果两边距离一样则返回偶数
           int = round 四舍五入的整数
           max（a，b） min（a，b）参数int long float double 
           pow（a，b） a的b次方（参数double 返回值double）
           sqrt（double a） 获取给定参数的平方根
           double = random(); 随机产生一个  [0.0-1.0]

 5.Math.randon()计算小数的时候精确度可能会有些损失
               0-9之间的随机整数
               int Value = （int）(Math.random()*10);
               5.0----10.9之间的小数
               （Math.random()*6)+5
               0.0----0.99999 * 6
               (0.0---5.49999)+5

Random类

1.在java.util包中的类 需要import导入
2.没有任何继承关系 默认继承Object类
3.查找构造方法----》如何创建对象
        Random r = new Random();
4.类中常用的方法
        r.nextInt(); 随机产生int范围内的整数  有正有负
        r.nextInt(int bound);随机产生一个[0-bound]整数
                 注意bound必须为正数 否则会出现如下的运行时异常
                 IllegalArgumentException
        r.nextFloat() 随机产生一个[0.0--1.0]
        r.nextBoolean()随机产生一个boolean值 true false
        //调用的方法都需要用相对应类型的变量接收值

UUID类

1.所属的包 java.util  需要import导入
2.没有任何继承关系 默认继承Object类
3.构造方法有 没有无参的 我们通常不会创建对象
          UUID  uuid = UUID.randomUUID();
          System.out.println(uuid.toString());//数据库表格主键primary key
          产生一个32位的随机元素 每一个位置都是16进制的数字

BigInteger

1.所属的包java.math  需要impor导入
2.继承自Number
3.如何创建对象 提供的构造方法都是带参的
        通常利用String参数的构造方法创建这个类的对象
        BigInteger bi = new BigInteger{"123"};
4.类中常用的方法
        做四则运算
        add()  substract() multiply() divide()
5.小例子 设计一个方法 用来设计给定数字的阶乘 
       //设计一个方法 用来设计数字的阶乘
       //参数 返回值
       Public BigInteger factorial(int num){
            BigInteger result = new BigInteger("1");
            for(int i = 1;i <= num;i++){
                result=result.multiply(new BigInteger(i+" "))
        }
        retrun result;
      } 

BigDecimal类 超过了double取值范围

1.所属的包  java.math包
2.继承Number类
3.通常可以通过 带String参数构造对象
4.类中常用的方法
         做四则运算
         add()  substract() multiply() divide()
         两个参数前面保留小数点之后的位数，后面的参数是设置的格式如何保留
         对象.setScale(2,BigDecimal.ROUND_DOWN);

DecimalFormat——-格式化

1.所属的包 java.text
2.import导入才能使用
3.通过带String参数的构造方法格式化创建成一个字符串
            DecimalFormat df = new DecimalFormat（"000.###"）;
            String value = df.format(12.45);
            System.out.println(value);
1.

包装类

1.类所在的包
2.类的关系 自己默认继承 实现
3，类中提供常用方法
4.是否可以创建对象 调用 方法本身是静态的

包装类（封装类） 1.5版本之后自动拆包
byte----Byte   short----Short   int------Integer  long-----Long
float-----Float  double-----Double char-----Character boolean----Boolean
1.八个包装类都在同一个包下  java.lang包  不需要import导包自己使用
2.八个包装类有六个都是与数字有关  都默认继承父类Number
3.八个包装类都实现了Serializable，Comparable
4.八个包装类都带有自己对应类型参数的构造方法
 八个包装类中有7个（除了Character）有构造方法重载 带String类型
5.创建对象  对象调用方法
     有六个与数字相关的类都继承Number   xxValue();将一个包装类类型转化为对应的基本类型（拆包）
Interger i1 = new Interger（10）//引用数据类型 包装类
 int value = i1.intValue();

 int value  = Inter.parseInt("123")  Float.parseFloat("123.45")
 int value  = new Integer("123");

经常在笔试中出现的问题

integer i1 = 10;
integer i2 = 10;
integer i3 = new Integer(10);
integer i4 = new Integer(10);
System.out.println(i1==i2);//true
System.out.println(i1==i3);//false
System.out,println(i3==i4);//false
System.out.pritnln(i1.equals(i2));//true
System.out.pritnln(i1.equals(i3));//true
System.out.pritnln(i1.equals(i4));//true

==与equals()的区别

==可以比较基本数据类型 也可以比较引用数据类型（变量中存储的内容）
如果比较基本类型比较的是变量中存储的值
如果比较的是引用类型比较的是变量中存储地址的引用
equals()是Object类中继承过来的方法==一致 如果想要改变比较规则 可以重写equals方法
由于integer类就重写了equals()所以Integer比较的是数值

考察Integer类加载的时候有一个静态空间

空间内立即加载Integer类型的数组 内存储256个Integer对象 -128-127
如果我们用的对象范围在这之内 integer i1 = 10;直接取静态元素区中找对应的对象
如果我们用的对象范围超出了Integer i1 = 1000; 会帮我们创建一个新的Integer对象

内部类

成员内部类

将一个类直接定义在类的里面，作为成员，与属性或方法层次一次
成员内部类可以与正常类一样 使用不同的修饰符去修饰
好处1.省略了一个.java文件 
好处2.成员内部类可以访问外部类的所有成员 包括私有的
若想要在内部类中通过对象.调用外部类成员  外部类.this.外部类成员
内部类存在后 源代码进行编译 产生一个字节码 Demo$InnerDemo.class

局部内部类

将一个类定义在方法/块里面,作为成员的内部结构，与临时的局部变量一个层次
局部内部类像是一个局部变量一样，不能用public protected privtae及staic只能用abstract或final
局部内部类命名规则Demo$InnerTestMethod
局部内部类使用的变量只能用final修饰

匿名内部类

成员匿名内部类<br>
局部匿名内部类

public interface Test{
          public void test();

}
 Test t = new Test{
          public void test(){
          }
} ;
通常接口或抽象类的具体子类这样写
开发中为了省略一个类文件 上诉写法比较常见
匿名内部类很特殊 只有类体 没有类的所有结构（修饰符 名字 继承 实现）      
不能用任何修饰符来修饰 匿名内部类也没有任何构造方法

静态内部类

成员静态内部类
不需要外部类对象，通过正常的方式直接创建内部类
静态元素不能访问非静态成员（自己类和外部类）

枚举类enum

一个类中的对象 认为个数有限且固定的，可以将每一个对象一一列举出来

 1.试一试若没有枚举类型的时候如何动手设计（静态常量 单例模式）Day（类 当做描述星期七个对象）
      private 构造方法
      public static final 属性 = new
      //构造方法私有
        private Day(){}
      //所有对象都是属性
      public static final Day monday = new Day();
 2.JDK1.5版本后可以直接定义enmu类型
      我们自己定义的enmu类型直接默认继承enmu（java.lang包）
      我们自己定义的enmu类型不能再写extrends但是可以实现
      Enum类型
             有两个属性
             name------->枚举对象的名字   name()获取name的属性
             ordinal------>枚举对象在罗列中的顺序  类似index 也从0开始 ordinal获取序列号
             常用的方法
             valueof()  通过给定的name获取对应的枚举对象
             values()   获取全部的枚举对象---->返回一个数组 Day[]
             compaerTo() 可以比较两个枚举对象 int
             toString()  由于这个方法没有final修饰 可以覆盖（重写）
3.我们也可以在enum中描述自己的一些属性或方法
      必须在enum类中第一行 描述一下枚举的样子 最后需要分号结束;
      可以定义自己的属性
      类创建过程中 帮我们创建枚举类型的对象
      需要给枚举型提供对应样子的构造方法 方法只能private修饰 可以重载

内存机制问题

栈内存----->Person p = new Person();----->堆内存   方法区----类模板
栈内存----->创建开始  用完立即回收   StackoverflowError
方法区----->类 常量 静态 只有一份回收不了
堆内存----->new创建的对象 Garbage Collection 垃圾回收器

Runtime类之中提供了几个管理内存的方法
        maxMemory
        totalMemory
        freeMemory
        堆内存溢出错误OutOfMemoryError
Object类中有一个finalize方法 如果重写也能看见对象回收
GC系统提供的一个线程  回收算法

设计模式

策略者模式 Strategy   ——— 行为型模式

用来解决 执行流程固定 执行结果由于提供不同策略而不同

              银行类
                  profession（人）{  人----抽象类 接口（不能产生对象） 传递一个子类对象
                  欢迎用户进来
                  叫号
                  办理
                  离开
                  欢迎您下次再来
                  }
             长者   年轻人  vip
            //按普通设计  可能有问题
              1.三个不同的人类方法名不一致（可以）
              2.银行办理业务的方法写了3个
            //解决上诉所述问题可以在三个人之上创建一个父类
              1.解决桑个人类中相同代码 比如name属性 比如get方法之类
              2.父类定义的三个方法可以是抽象类 解决了子类命名不一致问题 子类执行也不一致
              3.父类可以作为参数传入银行


  //主函数
     public static void main (String[] args){
          Bank bank = new bank ();
          Person p = new Oldman(长者); //父类作为参数
          bank profession（p）;//银行欢迎长者来办理业务 调的是子类对象
       }  



 //银行三个方法写成一个
       public class Bank{
       //开门  等待用户进来办理业务
       public void profession（Person person）{
       System.out，println（person.getName()+"客户进入银行啦"）
       person.callNumber();
       person.transact();
       person.leave();
       }

//抽象类 
       public abstract class Person{
       protected String name;
       public String getName(){
        return this.name;
        }
        //1.进银行叫号
        public abstract void callNumaber();
        //2.去窗口办理
        public abstract void transact();
        //3.办理完毕离开啦
        public abstract void leave();
       }

设计模式

适配器模式 Adapter

定义一个规则------->和尚 吃斋 念经 打坐 撞钟 习武
适配器
鲁智深 鲁达 形态丑陋 面貌凶顽 
方丈说 此人上应天星 心地刚直 虽时下凶顽 命中驳杂 久后却得清净 证果非凡 汝等不及他
public abstract class AbstractBox implements Box{
          public booolean add(element);
          public void add(int index,int element){//具体化
          }
          public void addAll(){//具体化
          }
          public int get（index）;
          public int remove（index）;
          public int size();
          }

Java面向对象的四大特性

继承 封装 多态 （抽象）

多态

同一个对象 体现出来的多种不同形态（身份）将一种行为表现出不同效果要想实现多态的效果 需要先有继承关系

体现

              1.父类类型的引用  指向  子类的对象
                   Person p = new Teachher();
              2.该引用只能调用父类定义的属性和方法
              3.如果子类中将父类的方法重写,那么调取方法后执行的结果是子类重写之后的那个结果
              如果父类与子类有同名的属性           执行父类的属性
              如果父类与子类有同名的方法（重载）      执行子类重写之后的方法
              4.若想要调用子类中独有的成员
              （强制类型转换）造型 铸型 （向上/向下转型）//把父类引用向下转型
              5.造型时（强制向下转型时）可能会出现一个运行时异常
              ClassCastException   造型 铸型 异常
              如果想要避免造型异常可以用instanceof关键字来进行判断// O instanceof Student 对象是否属于后面类型


                                      Object
                          hashCode equals toString getClass......
                          Animal
                     name属性 eat sleep
               Person                                      Pig
           name属性 重eat 重sleep 独talk             name属性  重sleep
          Teacher                     Student                  
name属性 重eat 独有teach       name属性 重talk 独study


            Object o = new Teacher();//向上转型
            o.hashCode() o.toString();
            Animal a = (Animal)o;//向下转型
            a.hashCode() a.toString a.name a.eat() a.sleep()
            Person p = (Person)o;
            p.hashCode();p.name p.eat p.sleep p.talk

异常

1.InputMismatchException  输入不匹配
2.NumberFormateException  数字格式化异常
3.ArrayIndexOutBoundsException  数组索引越界
4.NegativeArraySizeException  数组长度负数
5.NullPointerException   空指针异常
6.AirthmeticException    算数异常
7.ClassCastException     造型异常

abstract 抽象类

不具体 没有执行过程 只是一个概念

可以修饰什么

修饰方法
用abstract修饰符修饰的方法 只有方法的构造  没有方法执行体叫抽象方法
当然注意native修饰的方法虽然没有方法体 但是不是抽象方法 只是执行的过程是其他语言写的 不属于抽象类
用abstract修饰符修饰的类 叫抽象类

修饰后有什么特点

抽象类中必须要有抽象方法吗？ 不是必须含有抽象方法
抽象方法必须放在抽象类中？ 目前来看必须要放在抽象类中（或接口中）普通类是不许有抽象方法

研究一下什么叫抽象类 抽象类有什么特点？

1.类里面有什么 成员
          属性    可以含有一般的属性  也可以含有 private static final 等
          方法    可以含有一般方法    也可以含有 private static final 等 
                  注意：抽象类中允许含有抽象方法（只有方法结构 没有方法执行体）
          块      可以含有一般程序块  也可以含有static程序块
          构造方法  可以含有一般方法，包括重载
2.类如何使用  创建对象
          抽象类含有构造方法 但我们不能通过调用构造方法创建对象
          抽象类只能通过子类单继承来做事
3.类和类的关系
          抽象类-----直接单继承---抽象类   可以
          抽象类-----直接单继承---具体类   可以
          具体类-----直接单继承---抽象类   不可以（）
4.小问题
抽象类中能不能没有抽象方法 全都是具体成员  可以
抽象类能不能没有具体成员 全都是抽象方法 可以 ---->抽象到极致--->接口
接口可以理解为是抽象类抽象到极致------->还是一个类的结构 不能用class修饰 改用interface修饰

interface 接口

什么是接口？

接口也是一个类的结构 只不过用interface修饰 替换原有的class

有什么 成员

属性            不能含有一般属性 只能含有公有的静态常量 public static final
方法            不能含有一般的方法 只能含有公有的抽象方法（1.8以后default修饰具体方法）
块              不能含有一般程序块 也不能含有static块（块本身就是具体的 接口中不让有具体的）
构造方法        不能含有构造方法

如何使用 创建对象

不能创建对象
只能通过子类多实现（implements）来做事
public class A implements B,C,D{

}

与别的类结构关系

接口不能继承别的类   最抽象
抽象类--------直接多实现-------接口  可以
具体类--------直接多实现-------接口  不可以（不能直接将抽象方法具体化）
接口----------多继承-----------接口  可以直接多实现

类的加载关系

存在继承关系的类 加载机制 及执行过程
加载类的过程-----静态元素已经加载
new Person();
1.加载父类
2.父类会产生自己的静态空间 属性 方法 块
            执行静态块
3.加载子类
4.子类会产生自己的静态空间 属性 方法 块
            执行静态块
5.开辟对象空间  
6.加载父类的非静态成员  属性 方法 块 构造方法 
7.执行块 执行父类的构造方法
8.加载子类的非静态成员 属性 方法 块 构造方法
9.执行块 执行子类的构造方法
10.将对象空间的地址引用交给变量存储

native 本地的

Java源代码看到native就已经再也看不到后续代码
后续会调用其他编程语言C++或C执行内存操作 帮我们操作
Object类中的一个方法 hashCode

设计模式

                1.设计模式不是知识点

                2.设计模式是一种设计经验的总结

               
3.设计模式用来解决某些场景下的某一类问题的—->通用的解决方案

                4.有了设计模式之后 可以让代码更容易被理解 确保了复用性 可靠性 可扩展性

设计模式分为三类

1.创新型模式（5种）-------->用于解决创建对象的过程
 单例模式  工厂方法模式  抽象模式 工作模式 建造者模式 原型模式
2.结构型模式（7种）-------->把类或对象通过某种形式结合在一起 构成某种复杂或合理的结构
 适配器模式 装饰者模式 代理模式 外观模式 桥接模式 组合模式 享元模式
3.行为行模式（11种）------>用来解决类或对象之间的交互 更合理的优化类或对象之间的关系
 观察者模式 策略模式 模板模式 责任链模式 解析器模式 迭代器模式 命令模式 状态模式 备忘录模式 访问者模式 中介者模式

单例模式

设计------>一个类只能创建一个对象 有效减小内存占用空间
设计一个系统----->百度  搜索引擎
 public class Baidu{
           public void 搜索（String keyword）{
           }
 }
创建一个baidu对象 new
调用搜索的方法 做事情 方法只执行一遍
同一时间有很多很多很多的人在使用这个系统
对象------>只能创建一个 堆内存就开辟了一个空间
调用一次方法----->临时执行一次 方法执行空间就回收了

单例模式的实现

 1.私有的构造方法
 2.私有的静态的当前类作为属性
 3.公有的静态的方法当返回值

 饿汉式（立即加载） 对象启动时就加载啦
           不会产生对象就没有拿来使用的问题 空指针异常
           启动项目时的对象加载过多 有些还没有使用 产生服务器承载压力问题
 懒汉式（延迟加载）对象什么时候用到了 才会加载
           可能会由于没有操作好 导致异常（很严谨）
           启动项目时候只有需要的加载 不需要的时候还没有创建 不会浪费空间
*生命周期托管（单例对象别人帮我们处理）对象加载过程交给别人 

   private static SingleTon;               //直接=new SingleTon()饿汉式
   public static SingleTon getSingleTon(){
     if(single=null){
     Single = new SingleTon();            //延迟加载方式  懒汉式
     }
     return single;
  }
public static void main(String[] args){
    SingleTon s1 = Singleton.getSingleTon();
    }
}

权限修饰符

public       公共的        本类      同包    子类  当前类的任何位置只要有对象都可以使用
protected    保护的        本类      同包    子类 （通过子类对象在子类内部访问）
默认不写     默认的        本类     同包
private      私有的

1.能修饰什么  2.范围如何
权限修饰符可以用来修饰   类本身   和类中的成员（除程序块）
权限修饰符用来修饰类的时候只有两个可以用 （public 默认不写）
权限修饰符可以用来修饰类中的其他成员

Java类和类直接的关系

继承  关联 多态（抽象）

封装：将一些数据或执行过程 进行一个包装

目的：保护这些数据或执行过程的安全隐藏细节，增加复用性

对属性本身的封装：

                                   属性私有：（封装在类中）

                                   提供操作属性的公有方法


特征修饰符

1.可以修饰什么
2.修饰后什么特点

final

最终的   不可更改的
  修饰变量  
         如果在定义时没有赋初始值
         给变量一次存值的机会（因为变量在栈内存空间内 没有默认值 如果不给机会 就都没法用了
         一旦变量存储了一个值若用final修饰后则不让改变----相当于常量
         注意变量类型是基本类型还是引用类型
         如果修饰的是基本数据类型 则变量内的值不让更改 常量
         如果修饰的是引用数据类型 则变量内的地址不让更改对象唯一
  修饰属性
         全局变量 存储在堆内存的对象空间有一个空间
         属性如果没有赋值  有默认值存在
         属性用final修饰后 必须给属性赋初值 否则编译报错
         特点与修饰变量一致
         注意变量类型是基本类型还是引用类型
         如果修饰的变量是基本数据类型 则变量内的值不让更改 ---常量
         如果修饰的变量是引用数据类型 则变量内地址引用不让更改---对象唯一
 修饰方法
         方法是最终的方法 不可更改
         子类继承父类的方法 可将父类的方法重写（覆盖）
         final修饰的方法 要求不可以被子类重写（覆盖）
 修饰类本身
         类是最终的  不可更改
         此类不可被其他字类继承
         通常都是一些定义好的工具类
         Math Scanner Intneger String

static静态的

1.可以修饰：修饰属性 修饰方法 *修饰块 修饰类（内部类）
2.特点：
     1.静态元素在类加载时就初始化了，创建的非常早，此时没有创建对象
     2.静态元素存储在静态元素区中，每一个类都有一个自己的区域，与别的类不冲突
     3.静态元素只加载一次（只有一份），全部类对象及类本身共享
     4.由于静态元素区加载时候，可能没有创建对象，可以通过类的名字直接访问
     5.静态元素区Garbage Collection 无法管理，可以粗暴认为常驻内存
     6.可以理解静态元素不属于任何一个对象，是属于类的
     7.非静态成员（堆内存对象里）中可以访问静态成员（静态区）
     8.静态成员中可以访问静态成员（静态区）
     9.静态成员不可以访问非静态成员
     10.静态元素不可以出现this或super（静态元素属于类）