JavaCTO

集合（集合类的对象）是用来管理其他若干对象的。
集合中保存的是对象的引用，数组是最基本的集合

集合框架

1，接口
集合中用到的类，接口在java.util包中，在使用时注意将其引入import。

Collection

用来管理多个对象，集合中的每个元素都是对象。

1)List 一个List的实现类的对象在管理多个对象时会按顺序组织对象（即按照将对象放入的顺序存储）List实现类的对象是有顺序的，List实现类对象中的内容是可重复的。（注意，顺序和排序的区别）
2)Set 一个Set的实现类表示一个数学概念上的集合，Set的实现类的对象中的元素是无顺序的，也就是不会按照输入顺序来存放，Set的实现类对象中的元素是不重复的。
3)SortedSet,他是Set的子接口，他的实现类会对集合中的元素进行排序。但是要指定排序规则，他会按排序规则进行排序。

Map，Map中没有对象，而是键值对，由Key，value组成的键值对
Key是没有顺序，不可重复的。
value是可以相同的,一个Key和一个value一一对应。

Map 接口（以下介绍其子接口）
SortedMap，这个接口的实现类同样可以实现，不过是对键值对中的Key进行排序，这个接口的实现类也是要指定排序规则的。

阅读全文…

Java中的内部类，内部类也就是定义在类内部的类。是编译时语法。

内部类的分类：

1. 成员内部类
2. 局部内部类
3. 静态内部类
4. 匿名内部类（图形监听时要用到，要掌握）。

一、成员内部类

四个访问权限修饰符都可以修饰成员内部类。

内部类和外部类在编译时是不同的两个类，内部类对外部类没有任何依赖。

内部类是一种编译时语法，在编译时生成的各自的字节码文件(Outer.class和Outer$Inner.class)，内部类和外部类没有关系。

内部类中可以访问外部类的私有成员。（与C++的友员相比，不破坏封装）

作为外部类的一个成员存在，与外部类的属性、方法并列。

内部类和外部类的实例变量可以共存。

在内部类中访问实例变量：this.属性

在内部类访问外部类的实例变量：外部类名.this.属性。

在外部类的外部访问内部类，使用out.inner.

阅读全文…

一、复习

1、Object 所有的类直接或间接的父类
        finalize:垃圾收集的时候调用
        toString:返回对象的字符串形式
        equals:判断两个对象内容是否相同
2、包装类
     8种基本类型各自提供了对象形式
3、异常处理
     提高容错性
     异常的分类：Throwable
                Error    :错误，不可避免，不可处理
                Exception:Runtime：未检查：可处理可不处理，首先应该努力避免异常（本可避免的）
                          非Runtime：已检查：必须要处理
     异常对象的产生：throw 抛出异常，沿着方法调用链反向传递
     异常处理：throws 消极，声明抛出
              try-catch 捕获异常
              try-catch-finally
              try-finally
     方法覆盖 ：子类覆盖方法不能比父类被覆盖方法抛出更多的，范围更宽的异常
4、自定义异常

二、断言

在JDK1.4之后开始出现，是一个调试工具
其后跟的是布尔类型的表达式，如果表达式结果为真不影响程序运行。如果为假系统出现低级错误(Error)，在屏幕上出现assert信息。

assert a%2==0;
编译器的默认设置：把断言语句忽律 
javac -source 1.4 源文件名   //表示用1.4新特性编译
java -enableassert(-ea) 类名  //打开断言功能
assert a%2==0:"a必须是偶数";  //出现错误时的提示信息
assert只是用于调试。在产品编译完成后上线assert代码就被删除了。

1、异常的处理

（1）声明抛出 

是方法声明的第五部分  throws+异常名字（多个异常用“，”分隔）
出现异常，不处理，抛给上一级处理
并且子类抛出异常的范围不能比父类抛出异常的范围更宽。

(2）捕获异常

       try – catch
       try – catch – finally
       try – finally     //不捕获异常，当异常发生，返回上一级之前，要运行finally中的代码
       以上语句可以嵌套

       返回类型 方法名（参数）｛
        try{
            可能出错语句
            正常语句
        }catch(异常类 e)｛  //某种异常的引用
            对异常的处理
        ｝
        正常语句       
    ｝

阅读全文…

Java中的异常是为了在错误发生的时候减少损失，提高程序的容错性。

1、异常的分类

Throwable有两个子类：Error和Exception。

一个Error对象表示一个程序错误，指的是底层的、低级的、不可恢复的严重错误。此时程序一定会退出，因为已经失去了运行所必须的物理环境。

对于Error错误我们无法进行处理，因为我们是通过程序来应对错误，可是程序已经退出了。

我们可以处理的Throwable类中只有Exception类的对象（例外/异常）。

                       Throwable
                          |
                  ——————
                  |                 |
              Error             Exception
                                    |
                             ————–
                            |              |
                  RuntimeException      非Runtime异常
                  未检查异常             已检查异常
                  由于程序员疏忽造成的    不可避免的
                  可避免的               必须处理
                  可处理，可不处理

2、异常的产生和传递

throw  new一个异常对象;   —表示抛出一个异常

throw new NullPointerException();
相当于return，函数返回上一级

异常的传递：
沿着方法调用链反向传递！
当一个方法中出现异常，而没有作处理，则以异常对象为返回值返回调用处（逐级传递）
异常返回给虚拟机时，虚拟机终止退出，程序结束

Java中的简单数据类型与封装类

JAVA为每一个简单数据类型提供了一个封装类，使每个简单数据类型可以被Object来装载。

除了int（Integer）和char（Character），其余类型首字母大写即成封装类类型名。

转换字符的方式：

int I=10;
String s=I+” ”;
String s1=String.valueOf(i);

Int I=10;
Interger I_class=new integer(I);

封装类.字符串.基本类型

int——————–(Integer(x.toString))—————->Integer
String —————–(Integer.valueOf() )—————->Integer
Integer—————–(x.toString() )———————>String
int———————-(100+””)————————->String
String——————(Integer.parseInt() )—————>int
Integer—————–(Integer.intValue() )—————>int

一、interface复习

接口
是个特殊的抽象类，
属性：公开静态常量，方法：公开抽象方法
没有构造方法
接口之间可以多继承，一个类在继承另外一个类的同时，和可以实现多个接口

优点：
1、实现多继承，不会破坏类之间的单继承简单的树状关系。区分主类型和次要类型。
2、标准，解耦合工具

标准的使用者和标准的实现者通过借口隔离开，使得接口实现者的改变对使用者没有影响

接口的回调：
有了接口之后，先有接口使用者，后有接口的实现者，把接口实现者对象传给接口使用者，接口使用者通过接口，调用接口实现这中的方法

阅读全文…

接口是一种程序结构，是特殊的抽象类。

接口中的方法必须都是公开的抽象方法（public abstract），接口中的属性都是公开静态常量（public static final）。 

接口中没有构造方法

1
2
3
4
5
6
7
8
9
10
11
12

  abstract class ClassA{                                  
       public static final int A = 10;
       public static final double B = 3.14;
       public abstract void m1();
       public abstract void m2();
   }
   interface IA{
       int A = 10;
       double B = 3.14;
       void m1();
       void m2();
   }   //与上面的抽象类逻辑上等价，编译之后，也会生成一个IA.class文件

所以一个源文件中可以写多个接口，但只能有一个公开接口，并且要与源文件的名字一致

阅读全文…

static

1. 属性：类变量；全类共有；类加载时初始化；类名访问
2. 方法：静态方法；类名调用；静态方法中不能访问类的非静态成员，可以覆盖，只能被静态方法覆盖；没有多态初始代码块；类加载时运行

类加载：
一个类编译之后会形成.class文件，储存了类的全部信息。
当JVM第一次使用一个类的时候，会根据ClassPath找到对应的.class文件，用输入流把文件中的信息读入JVM并保存起来，这样，JVM就“认识”了这个类

类加载时机：第一次用这个类的时候

1. 第一次创建类的对象，会加载
2. 访问类的静态成员，会加载
3. 声明类的引用，不会加载
4. 加载子类，必然先加载父类
5. 如果调用的是子类从父类中继承下来的静态方法，只会加载父类
6. 如果访问的是类的静态常量，如果在编译的时候能够确定这个常量的值，则运行时不会加，否则，编译时无法确定常量值，那么运行时就会加载

阅读全文…

abstract修饰符可以用来修饰类（Class）和方法(method)      

一、abstract修饰类Class 抽象类

abstract修饰的类为抽象类：

• 不能创建对象，可以声明引用，并通过引用调用类中的方法
• 主要用于被子类继承的，可以用父类引用指向子类对象

二、abstract修饰方法method

• abstract修饰的方法只有声明，没有实现，用“；”代替“{ }”
• 需要子类继承实现（覆盖）。
• 如果一个类中有抽象方法，那么这个类必须是抽象类。
• 抽象类中不一定有抽象方法

阅读全文…