JAVA

数据类型

引用数据类型

应用数据类型默认值为null

• Class(类)

  • 如何理解类和对象?

• 接口(interface)

• 数组

  • 一维数组

    当数组中每个元素都只带有一个下标时，称这样的数组为一维数组。

  • 二维数组

    数组中的元素还是数组

    • 声明和创建

      • 静态

        String[][] s=new String[][]{{"www","sssss"},{"www","sssss"}};

      • 动态

        第一种方式
        int[][] ss=new int[3][2];//3表示二维数组的长度，2表示二维数组里面的一维数组的长度
        第二种方式
        int[][] ss=new int[3][];
        ss[0] =new int[];
        ss[0] =new int[];
        ss[0] =new int[];

  • 常见异常

    • 下角标越界

      异常代码：ArrayIndexOutOfBoodsException

    • 空指针异常

      NullPointerException

基本数据类型

基本数据类型默认值为0

• 数值型

  • 整数型

    • byte(1字节)

      byte储存空间为1字节
      1B（byte，字节）= 8 bit（见下文）；
      表数范围
      -128 ~ 127-128 = - (2^7)
      127 = 2^7 – 1
      //后面我们详细说明
      字节类型

    • int（2字节）

      整型

    • short(2字节)

      类型：短整型
      表数范围
      -215 ~215-1

    • long（4字节）

      长整型

  • 浮点型

    • float(4字节)
    • double（8字节）

  • 获取随机数

    Math.randm();

• 布尔型

  • boolean（2字节）

• 字符型

  • char(2字节)

异常

异常体系结构

• Throwable

  • Error

    没有针对性的代码可以进行处理

  • 子主题 2

• Exception

  有针对性的代码可以进行处理

  • 编译时异常

    • FileNotFoundException

      文件找不到异常

  • 运行时异常

    • NullPointerException

      空指针异常

    • ArrayIndexOutOfBoundsException

      下角标越界

    • ＳtackOverflowError

      栈溢出

    • ArithmeticException

      算数运算异常

处理异常的方式

• 抓抛模型

  抛 ：当我们执行代码的时候，一旦遇到异常代码，系统会根据异常的类型创建对应的异常类的对象并抛出。

抛出给方法的调用者，同时终止程序的运行。
①系统向往抛异常
②手动向外抛异常

- try-catch-finally

  格式

      try{

      可能会发生异常的代码

      }

      catch(异常的类型1 变量){

               异常的处理方式1;

           }catch(异常的类型2 变量){

               异常的处理方式2;

           }

           ......

           finally{

               一定会执行的代码;

           }

  说明：

1. 当try中的代码在执行的过程中，一旦执行某行代码时发生异常，系统会创建对应的异常类型的对象向往抛。
2. text 复制

   1

               catch后面的异常类型会和抛出的异常的对象进行类型匹配。一旦匹配成功则执行相应的异常处理的代码。

3. text 复制

   1

                当catch中的代码执行完毕时将再执行finally中的代码。finally中的代码再执行完毕后跳出该结构继续向下执行其它代码。

4. text 复制

   1

              2.可以有多个catch语句，但是catch后面的类型如果有子父类关系，子类在上父类在下。

5. text 复制

   1

              3.可以写成try-catch-finally, try-catch, try-finally三种结构

6. text 复制

   1

              4.finally可以省略。如果有finally那么其中的代码一定会执行。

7. text 复制

   1

              5.常处理的异常方式 ： getMessage()  ：输出异常错误信息的名称

8. text 复制

   1

                      printStackTrace() : 输出异常的详细信息

        注意 ： 在实际开发中一般我们都不会处理运行时异常。

    - finally

      再谈finally: finally中的代码一定会执行

           1.无论异常是否能捕获到或者处理异常时再次发生异常，finally都会执行。

           2.就算在try中或者catch中已经调用return了，finally中的代码也一定会执行。

- throws

-一 格式 ： 方法名() throws 异常类型1，异常类型2.....{

               }

               

二 throws捕获到异常后自己不处理，

抛给方法的调用者进行处理。

-三 throws和try-catch的区别？

         1.throws自己不处理异常，将异常向上抛，抛给方法的调用者处理。最后还是需要try-catch进行处理。

         2.try-catch是真正的处理了异常

         

四 什么时候选用throws?

             如果在main中调用了多个方法而且传输了数据。一旦因为数据的错误导致的异常，中间的所有的方法都不能进行处理。

             这个异常必须由传输数据的那个人来进行处理。

       

五 什么时候不能使用throws?

           1.异常必须处理时不能使用

           2.如果父类被重写的方法没能抛出异常，那么子类重写的方法也不能抛出异常

           

六 子类重写方法抛出的异常不大于父类被重写方法抛出的异常

- throw
- 【throws】和【throw】的区别？

package

java为了方便对类进行统一的管理和划分所有包的概念

方法

变量

成员变量和局部变量的区别
成员变量可以是用权限修饰词
局部变量不可以使用权限修饰词
成员变量在类中，方法之外的声明的参数
局部变量声明在方法，构造器和形参当中
成员变量是有默认值的，
局部变量是没有默认值的

• 成员变量

  内存创建在堆中
  先有默认值然后赋值

• 局部变量

  内存创建在栈中

• 权限修饰符

  • private

  • public

  • 缺省的

    此修饰符就是什么都不写默认的

    • 此修饰符只能在本包类使用，其他包中是无法使用的

  • protected

• 形参

  写在方法上的变量

  1、可变形参
  int ... number

  方法的可变形参和相同类型数组的形参不构成方法的重载，应为可变形参的底层就是数组

  一个方法中只能有一个可变形参

关键词

• return

  • 在没有返回值的方法中，提前结束当前方法
  • 在有返回值的方法中，用来返回数据

• ｂｒｅａｋ

  • 跳出当前循环

构造器

• 作用

  • 创建对象

  • 给对象进行初始化

    • 权限修饰符　类名（形参列表）｛｝

• 格式

• 创建对象必调用构造器

• 说明

  • 如果在类中没有显示定义的构造器，系统会自动创建一个构造器
  • /如果自己已经定义了构造器，那么在创建对象时,系统不会自动创建构造器

super关键字

• 调用父类中的属性和方法
• 子主题 2

this关键字

• 调用当前类中的属性和方法，如果本类中没有，则找父类中的方法

重载

• 方法的重载就是方法名相同
• 形参类型不同

类型判断

• instanceof

I,O

序列化

• 什么是序列化？

  在Java中，对象序列化意味着将对象表示为字节序列。字节包括对象的数据和信息。序列化对象可以写入文件/数据库，并从文件/数据库中读取并反序列化。表示对象及其数据的字节可用于在内存中重新创建对象。
  (我自己的理解序列化就是将字节序列也就是将文件转为二进制字节，然后用ｉｏ写入写出的一个过程)
  序列化：文件的写出
  反序列化：文件的写入

面向对象

多态

• 作用

• 多态的前提

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

• 一种事物的多种行态

  • 动态绑定

    这是一个技术

    • 编译看左边，运行看右边

• 多态的体现

  • 广义上

    • 方法的重写

      • 动态绑定
      • 运行时多态

    • 方法的重载

      • 静态绑定

      • 编译时多态

        运行时就可以确定调用的哪个方法

    • 子类对象的多态性

• 子类对象的多态性

  • 父类的应用指向子类的对象

继承

• 面向对象生性之继承性

  • 格式

    A extends B A类（继承、扩展）B类

    A :子类（subclass）

    B:父类，超类，基类，superclass

  • 继承的好处

    1、减少了代码的重复、提高了地面的复用性，提高了扩展性、为多态提供了前提

    2、子类继承父类以后就拥有了父类中的属性和方法。（构造器不能被继承）

    3、父类中的属性可能因为封装子类不能再直接进行调用，但是可以通过间接的方式进行调用

    所以我们认为被封装后的属性还是被继承到了

    4、一个子类只能有一个父类，一个父类可以有很多子类

    父类的相对概念。父类为直接父类和间接父类

    5、子类不仅可以继承直接父类中的属性和方法还可以继承间接父类中的属性和方法

    6、一个类如果没有显示的继承其他类那么默认继承object类。（objet是所有类的基类）

    7、子类除了可以继承父类中的属性和方法，还可以创建自己的属性和方法

封装

• 将一个事物的所有特征写到一个类中，并且字段使用private关键字修饰，还有getset属性，给外部调用，保证其安全性

static

• 成员变量

  • 可以分为

    • 类变量（static修饰的变量）
    • 治理变量

  • 同一类的多个对象，各自拥有一份实例变量，共同拥有一份类变量

  • 但一个对象对类变量进行赋值或者修改后，其他对象看到的类变量

子主题 5

重载

• 两同一不同 ： 同一个类同一个方法名。一不同指的是形参列表的不同。
• 形参列表不同 ：形参的类型，个数，顺序。
• 同一个类中，相同的方法名，不同的形参列表，这就是重载

设计模式

设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式

• 单例设计模式

  • 懒汉模式
    text 复制

    1 2 3 4 5 6 7 8 9 10

    class A{//线程是不安全的
        private A(){}
        private static A a=null;
        public static  A getA(){
        if(a==null){
        a=new A();
        }
         return a;
        }
    }

  • 饿汗模式
    text 复制

    1 2 3 4 5 6 7

    class A{//线程是安全的
    private A(){}
    private static A a=new A();
    public static A geta(){
    return a;
    }
    }

• 代理设计模式

• 工厂设计模式

• 观察者设计模式

• 装饰设计模式

• 策略模式

object

object是所有类的跟

==和equals的区别

• ==：如果是基本数据类型那么比较的是具体的值，如果是引用数据类型那么比较的是地址值。判断两个应用的地址
• equals：如果没有重写equals方法，比较的是地址值，如果重写了equals比较的是属性值

枚举和注释

枚举

• 说明

  枚举类 ： 如果一个类的对象是可数多个的，那么这个类叫做枚举类。

   一 自定义枚举类（jdk1.5之前）

   二 使用enum关键字实现枚举类(jdk1.5)

   三 常用方法

   四 实现接口的枚举类

• 实现枚举类

  • 格式

    使用enum关键字实现枚举类(jdk1.5)

    格式 ：enum 类名{ }

• 构造器只能使用private关键字修饰

• ③枚举类的所有实例必须在枚举类中显式列出(, 分隔 ; 结尾).

  text 复制

  1

            列出的实例系统会自动添加 public static final 修饰

• ④JDK 1.5 中可以在 switch 表达式中使用Enum定义的枚举类的对象作为表达式,

  text 复制

  1

            case 子句可以直接使用枚举值的名字, 无需添加枚举类作为限定

• 枚举类的常用方法

  • values（）方法：返回枚举类型对象的数组。该方法可以很方便的便利枚举值
  • valueof（String str）：可以把一个可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。
    text 复制

    1

      如不是，会有运行时异常:IllegalArgumentException。

• 实现接口的枚举类 (每一个对象都可以重写接口中的方法)

注解

• 常见的三个注解

  • @Override

    限定重写父类方法, 该注解只能用于方法

  • @Deprecated

    用于表示某个程序元素(类, 方法等)已过时

  • @SuppressWarnings

    抑制编译器警告

• 自定义注解

  • 格式

    权限修饰符 @interface 注解名{}

• 元注解

  • 备注

    注解的注解（用在注解上面的注解）。

    text 复制

    1 2 3 4 5 6 7 8 9 10

        @Retention:用来说明使用该注解的注解的生命周期
    
            RetentionPolicy：
    
                SOURCE : (废弃了)源文件 - 编译期间
    
                CLASS:编译期间 - 运行期间
    
                RUNTIME:运行期间 （如果想要通过反射获取注解中的信息，那么该注解的生命周期必须是RUNTIME）
        @Target：用来说明使用该注解的注解可以使用在哪些结构上。

• 通过反射获取注解的信息

Collertion集合

在java、中用来可以储存多个对象的容器：集合，数组

数组的特点

2.1数组一旦创建成功，那么数据的长度就不可变

2.2数组的声明时的类型，就决定了数组储存的元素的类型

数组的缺点：

①数组的长度不可变，不能很好的进行扩容

②数组的属性和方法较少。比如缺少像增删改查，等这样的方法

③数组中只能用来储存的元素是有序可重复的。那么对于无序不可重复的无能为力

Collertion接口（单列集合）

• list：储存的元素是有序可重复的
• set：储存的元素是无序不可重复的

遍历

• ForEach

  • 增强for循环

    • 格式：
      for(元素的类型 临时变量 ： 集合/数组的对象){
      }

• Iterator

  • //返回Iterator接口实现类的对象（在此接口上的迭代器 - 用来遍历集合中的元素）
    Iterator iterator = c.iterator();

    /*

    • next() : 1.指针下移 2.获取指针指向的元素
    • text 复制

      1

          注意 ： 如果没有更多元素时再指针下移会发生NoSuchElementException

    • /
    • 子主题 1

Map（双列集合）

存放的是键值对

Map中所有的key可以看成是Set的集合。无序的且不可重复的。在Map中存放的key的数据（自定义类对象）

     必须重写hashCode和 equals方法

• 实现类

  • HashMap（主要实现类）

    • LinkedHashMap

  • Hashtable

    • Properties

  • TreeMap

xmind