Java面向对象编程小总结

第一章： Java面向对象编程概述
1.1：面向对象 ：（Object Oriented）OO；面向对象分析（OOA）；面向对象设计（OOD）；面向对象编程  （OOP）。
1.2：类和对象：类是对象的抽象，而对象是类的实例；对象都有属性和行为两大要素，属性是对对象的静态描述
    而行为则体现了对象的功能和行为。一个类的使用是通过对该类实例化来完成的。
1.3：面向对象的特征：封装，继承和多态；
    封装：把对象的属性和操作结合在一起，构成一个独立的对象。同过修饰符的使用外部对象不能直接操作对象的   
属 性，只能使用对象 提供的服务，。
    继承：即扩展，子类继承父类几乎全部属性和行为，但是继承只能是单继承，一个子类只能有一个直接父类；继承 是可以传递的。子类可以当作父类看。
   多态：通过方法重载和方法重写实现。
第二章：类
2.1：构造方法：构造方法可以是有多个的；不写构造方法时系统会给类一个默认构造方法，但是当添加了一个构造方法之后，默认构造放会被遮蔽掉，需要重写一个。
2.2：类的成员：属性和行为构成了类的成员。作为累的属性，可以是基本数据类型，也可以是引用类型；方法则体现出了行为；Get和Set方法作为一种约定被用于提供对属性的操作，尤其在Javabean中这两个方法必不可少并且规定很严格。
2.3：访问控制：
    public :公用的：全开放所有类都可以访问。
    private:私有的：即使子类也无法访问。
    protected :子类可以访问，即使不在同一个包中。同一包中的类也可以访问。
    （friendly)默认的：对同一包开放。
这些修饰词的添加体现了封装的特性。
  其他修饰词：
  static:静态的：被其修饰的成员将具有静态属性，运行中静态成员被优先加载。对静态方法的访问，直接类名+
          方法名就可以，而不必经过实例化。
 final:终态的：这种成员一经初始化后，将一直不可修改。同样被final修饰的类意味着该类不再有子类。常量。
 abstract:抽象的：抽象方法只有方法头，而无方法体，他只是对一个方法的规定，就像一个abstract方法必须在其
          子类要为其提供实现，除非这个子类也是abstract修饰的。与final相反，被abstract修饰的类被称为抽象类， 
          这种类是不能被实例化的（即便是它有构造方法），所以一定要通过子类来实例化。接口中的方法都是抽
         象方法。
this：当前的：表示当前类的成员或构造方法，其写法是：this.成员，this ()。
super：父类的：语法结构与this一样。在子类实例化时，总是在最先调用父类的构造方法，即使没有写super()，之
         类的语句。
2.4：组合
      一个类可以作为另外的类一个属性，即属性可以是引用性数据。这是一种设计模式。
2.5：内部类：
     定义在一个类内部的类就叫内部类，他只能被包含它的外部类访问。访问内部类必须同过外部类的一个实例来执行。内部类对于外部类的成员具有完全可见性，即内部类可以访问外部类的成员。
    方法内定义的内部类：这种类属于这个方法，该方法可以创建该内部类的实例，但外部类的其他方法无法访问
该内部类；这种类不能用访问修饰符声明；不能被声明为静态；只能访问所嵌入方法中声明为final的变量，引用方法的局部变量或作为传递给所嵌入方法的参数。
    静态内部类：静态内部类的方法不能访问外部类的实例变量，静态内部类的方法只能访问外部类的静态变量。
    匿名内部类：在事件模型中很有用。直接new。
2.6：对象的引用
   与基本数据不同，引用数据是依赖指针进行工作的。故当基本型数据和引用型数据均被当做参数传递个一个方法
时，基本型数据会复制一个完全一样的数据传入方法，在方法中对传入的数据进行操作是完全不会影响到方法外的这个数据；而引用型则通过将地址传入方法进行操作，所以当方法对这个参数进行任何的改动都会直接影响到方法外的这个引用型数据。
2.7：垃圾收集机制：JVM自动执行，System.gc()手动调用，但具体调用都由JVM控制，终结器,finalize()方法，当对象被销毁是会调用此方法，通过System类的runFinalizaton()方法来显示启用该方法。
第三章：继承
继承即扩展，其关键词是extends。
3.1：继承准则：总是让子类执行超类可执行的所有行为。
                          确保子类包含超类的所有信息。
                          向子类添加成员，从而定义子类的特有行为。
                          将共同特性迁移到超类上。
                          允许同一超类的不能子类执行相同的行为，但实现方式不同——方法重写。
3.2：is-a 关系可用于判断何时该不该用继承。
3.3：天生的父类：abstract修饰类；天生的子类：final修饰类。
3.4：超类的构造方法总在子类的构造方法前被调用，而终结器去不会被执行，除非子类的终结器显示地调用它，super.finalize()。
3.5：方法重载：发生在同一类中，方法名相同，方法的参数不同。如果方法名和参数相同，返回类型不同，
        将被视为语法错误。
       方法重写：发生在继承关系下的不同类中，方法名和方法参数以及返回类型都必须相同。
3.6：动态绑定：Java运行是环境将在运行的时候而不是编译的时候实现方法。
第四章：接口
4.1： 接口（interface）不是类。面向接口编程。简单的说，接口是一群抽象行为的集合。所有接口都是public
           和abstract类型，如果接口包含属性，所有属性都是static 和final类型。
4.2：定义接口: interface +接口名；实现接口：class +类名+implements+(接口名。。。。）。
4.3：通过接口实现了多重继承。应该这样设计类，让类封装所代表对象的属性和行为。对象外部的功能可通过
       接口来实现。
4.4：接口与抽象类的对比
      如果功能与对象自身密切相关，则在超类中使用抽象的基类方法。
      如果该功能只是对象的辅助行为，则可使用接口。
      该功能可被全局性的应用到其他无关对象，则可使用接口。
第五章：异常处理
5.1：异常基本语法结构：try{
                                            //可能会发生异常的语句，并抛出异常。
                                         }catch(XXException e) {
                                            //执行对异常的处理
                                        }..................
                                         finally{
                                          }
5.2 ：Exception类是所有异常类的父类，这要求自定义异常必须是Exception类的子类。其名字也一般约定为XXException。
5.3：在可能发生异常的地方可以使用throw语句抛出异常，而throws则用来传递异常。
5.4：在异常的语法结构中，finally语句是无论如都会执行的，即使他之器前调用了return语句，也同样会执行。
5.5：Java语言中的异常处理机制在一定程度上保证了正徐的健壮性。
5.6：异常类中的两个常用方法：getMessage()和printStackTrace()。
第六章：数组
6.1：一种基本的数据结构，用于表示相同的数据类型的集合，分为一维，二维和多维数组；其元素可以是引用型
         数据，也可以是基本数据类型；通过下标来访问其中的每个元素；下标从0开始；用for循环对数组进行遍历；
        数组的大小一经确定，是不可在更改的。同时数组也是一种引用型的数据。
6.2：数组的定义：如：String [ ] str = new String [ 1000 ]；或int [ ] a = { 1,3,4,5};
6.3：.length:对于一维数组它用来表示数组的长度，同时在多维数组中也可以使用，但要更复杂：如：
          对double [ ][ ] a = new double [2][4]表示一个2行4列的数组; a.length为2，表示两行；而a[1].length 则
          表示第二行 的长度。
6.4：数组有名字而数组中的元素是没有名字的，通过下标来表示他们。当然下表也可以是一个表达式，或者变量
6.5：与所有引用型数据一样，数组传递是传递的也是这个数组的地址。当数组中存放的是基本数据类型的时候，这个数据就实实在在的保存了这些数据，但是当数组中存放的元素是引用型数据的时候，这时候数组中存放的是这些
 元素的地址，这个需要注意。
第七章：Java常用类
7.1：包装类：用于提供基本数据类型和对象数据类型的转换，所以每一个基本数据类型都有其对应的包装类，
如int 型对应Integer类，char型对应Character类。
7.2：各种类型间转换的基本模式：
          基本型——>包装类：Integer in = new Integer(int a);
          String——>基本型： String str = "afadsf";  int a = Integer.parseInt(str);
          包装类——>基本型：int a =  in.inValue();
          String——>包装类： Integer in = Integer.valueOf(str);
          几个较为重要的方法：static String toBinaryString(int i) :以二进制无符号整数创建整形参数的字符串表示
          static String toHexString (int i):以十六进制无符号.................
          static String toOctalString(int i):以八进制无符号.......................。
7.3：String 类
        不可变类，提供字符串的保存和一些基本操作。
        构造方法：参数分别为();(char[ ]);(byte[ ])。
        常用方法：char charAt(int index):返回索引处的字符。
                          int compareT0(Object o):与另一对象进行比较，按顺序挨个比较字符串中的每个字符。
                         String concat(String str):将指定字符串连接到该字符串末尾。
                         boolean endsWith(String suffix):是否以suffix结尾。
                         boolean equals(Object o):于指定对象是否相等，大小写敏感。equalsIgnoreCase：忽略大小写。
                         byte[ ] getBytes():根据平台默认编码，将字符串转换为字节数组。
                         int indexOf(int ch):返回ch字符第一次出现的索引位置。
                         int lastIndexOf(int ch):返回ch字符最后一次出现的索引位置。 
                         String substring(int begainIndex int endIndex):提取子字符串。
                         String trim()：去掉字符串两端的空格字符。
                         String toUpperCase():返回字符串的大写形式，toLowerCase()为小写形式。
                         String [ ]split ("")：按正则表达式匹配查找。
7.4：StringBuffer类
        将Stirng 对象作为此类的够造方法参数以获得此类的实例。
        常用方法：StringBuffer append(String str):将字符串添加到该对象上。
                         StringBuffer replace(int star ,int end,String str):替换指定位置子字符串。
                         StringBuffer reverse():倒序排列。
                         String toString ():返回该buffer的字符串表现。
7.5：Date类
       日期类，用于保存日期。
        构造方法：new Date():返回从1970年1月1日00：00：00到此刻的毫秒数。
7.6：SimpleDateFormat类
         用于对日期文本格式化，有专门的格式控制字符串，如“yyyy年MM月dd日 hh:mm:ss”。
         解析日期字符串：parse方法。
7.7：Calender类
        日历类：用于对日期进行操作
         此类无法通过自身构造方法实例化，但提供了Calender static getInstance() 静态方法用以获得一个实例
        同时此类提供了许多字段用以对日期进行操作，同时有get/setTime方法来获得或设定时间。
第八章：容器类
8.1：JCF（ Java Collections Framework)Java集合框架。提供用于管理集合的接口和类，包括接口，实现类和
       算法类。
8.2：基本结构：
       Collention（接口）:List（列表），Set（集合）；
                      List：ArrayList，LinkedList，Stack和Vector。
                      Set：HashSet，TreeSet 。
                Map（映射）:HashMap,TreeMap.
     Iterator 迭代器：用于列表和集合的遍历，boolean hasNext():判断是否还有下一个元素；Object next()返回
                             下一个元素。
   一些方法：
   List :   boolean add(Object o); 末尾添加元素
              boolean remove(Object o);删除指定元素；
              Object   get(int index); 获取指定索引位置元素（index 是从0开始）
              int size();  返回容器容量                 
              Iterator iterator():返回一个迭代器。
              clear():清除所有。
             是有顺序的，不关注唯一。
HashSet :无顺序，唯一的
TreeSet: 无序向上排列， 中序遍历。
 Stack: 后进先出。
             Object  peek():返回栈顶对象，当不删除该对象。
             Object  pop(): 删除并返回栈顶对象。
             push(Object o):在栈顶添加一个对象。
HashMap：关注快速查找，这种查找方式是无需要遍历的。但有冲突情况产生，牵涉到哈西码和equals方法，这两个方法在Object类中就已经定义，但很多时候需要重 写实现。
         put(Object key,Object value):向映射中添加键值对。
         Object get(Object key) :根据给定的键返回对应的值。
         Set keySet();获得键的集。
TreeMap:与HashMap相比，他本身是有序的。数据层次化保存时将会选用树来保存。
8.3：算法类
     包括：Collections , Arrays, Comparator,Comparable。专门用来针对Collection上的操作，如：排序，替换
                拷贝和查找。其中大量都是静态方法。
     Arrays:专门用来针对数组的操作
     常用方法：sort();使用快速排序法对指定数组排序。
                      binarySearch()对已经排序的数组进行二分查找，如找到指定的值就返回索引位置，否则返回负值。                        fill();配置一个数组后，会依据数据类型来给定默认值。
                      equals();比较两个数组是否全部相等。
                      deepEquals()：对数组做深层比较，可以对一维以上的数组进行比较。
                      deepToString()：将数组做深层输出（字符串），对一维以上的数组也有效。
8.4：枚举
        Enumerations很向public static final int 声明，很多情况下可用枚举（Enums）替代，也可以用静态导入，（静态导入：可以使被导入类的所有静态成员在当前类中直接可见，即使用他们时无须在加上类名。导入方式为：
 import static java.lang.math.*;)。enum有一个抽象方法getString(),每个enum实例都提供这个方法的实现。
第九章： I/O类
9.1：输入输出流，有许多的I/O流，每种流都承担特定的功能，各流之间通过流的套接以流的方式来实现特定的
      I/O操作。分字符流（Writer,Reader）和字节流（Stream）。
9.2：构造流:典型形式是：BufferedReader br = new BufferedReader(new InputStreamReader(new InputStream("d:/a.txt")));
9.3：常见流类
       File类：专门负责文件和文件夹管理操作
       常用方法：File[ ] listFiles():返回当前文件夹下的所有文件夹和文件 对象。
                        String [ ] list():返回当前目录下的所有文件夹和文件名的字符串对象。
                        exists():判断文件是否存在。
                        isFile()：判断文件是否是文件。
                        isDirectory()：判断文教案是否是文件夹。
                        mkdir():创建目录；
                        mkdirs():创建多级目录；
                        delete():删除文件；
                        can Write/Read()：判断文件是否可写/读.
                        getAbsolutePath():获取文件的绝对路径；
                        getPath():获取文件的路径。
   RandomAccessFile类：用于随机读取文件（只对文件有效）。加入了指针和位置以实现读文件的随机访问。
                       seek(long pos)设置指针位置。
                       long getFilePointer():返回当前文件指针的位置。 
   InputStream/OutputStream 是所有字节流的父接口。有avilable()方法。
   Reader/Writer 是所有字符流的父类。无avilable方法。适用与纯文本文件，如html文件。
   InputStreamReader/OutputStreamWrite是从字节向字符转变的桥梁。
   BufferedReader等缓冲类，用于提高性能，同时提供了readLine()方法。
   ObjectInputStream/ObjectOutputStream类用与对象的序列化和反序列化，要实现对象的序列化，其类必须
            实现Serializable接口。输出流要先于输入流实例化，并在实例化后马上调用flush()方法，以免输入流被阻塞。
   PipedInputStream/PipedOutputStream类用线程间的通信。同样输出流要先实例化并flush();
    DataInputStream/DataOutputStream类使用基本数据类型的流。
9.4：所有的流在实例化是开启，操作完毕后都要调用close()方法关闭该流。对输出流而言，每次输出操作后都调
    用flush()方法以保证输出质量。
第十章：Java GUI 和 Swing
10.1：AWT:重量级组建，采用最小公分母法，依赖操作系统的内在组建。
         Swing:完全纯Java语言编写。不再受OS限制。
10.2：MVC:模型、视图、控制器。它是一种设计模式。
10.3：创建Swing窗体，一般同过继承JFrame来实现。
10.4：常用组件：
Container ;Dialog;JPanel;JSCrollPane;JTextField;JTextArea;JLable;JButton;JMenu;JMenuBar;JMenuItem;
JPassword;JCheckBox;JRadioButton;JList........
10.5：布局管理器：
 窗体的默认布局管理器是BorderLayout,它分东、南、西、北、中五个方向布局。
其他布局管理器还有：FlowLayout:流式布局。GridLayout:网格布局。
第十一章：事件委托模型
11.1：通过对每个组件注册合适的侦听器来是每个组件产生动作，组件注册的侦听器个数可以不止一个。
11.2：常见事件监听接口：
       ActionListener(ActionEvent e):用于按钮和菜单的点击动作。
       AdjustmentListener(AdjustmentEvent e):滚动条（ScrollBar)的调整。
       ItemListener （ItemEvent e):针对下拉列表等拥有条目的组件。
       KeyListener(KeyEvent e):侦听键盘按键。
       MouseListener/MouseMotionListener(MouseEvent e):鼠标按键、鼠标移（脱）动。（MouseAdapter)
       FocusListener(FocusEvent e):焦点侦听。
       WindowListener(WindowEvent e)：窗体动作。 (WindowAdapter)
第十二章：JavaBean与反射
12.1：JavaBean：java组件。狭义用来指Java GUI界面中的组件，要求严格。广义只要是提供了默认构造方法
       并对所有属性都提供了相应的get/set方法的 Java程序都叫JavaBean。
12.2：绑定属性：内置向其他组件通知自身更改的功能。
          约束属性：除了属性更改时通知其他组件外，接到通知的组件还可以禁止该更改。
          包含绑定属性的组件只要属性更改就会发送一个PropertyChangeEvent。
12.3：反射（reflect)
         12.3.1 使用的反射三个基本步骤：
         1：获得想要操作的目标类的java.lang.Class对象；
         2：通过getDeclaredMethods方法获得该类定义的所有方法列表；
         3：使用reflect API来操作第二步得到的信息。
        12.3.2 三种方式获得Class对象。
         Class.forName("类名");
         类名.class;
         对象名.getClass();
         12.3.3 几个常用相关方法：
         boolean isInstance(Object o):判断传入参数是否是此类的一个实例
         getConstractors():获得构造方法。
         newInsrtance(..);构建对象。
         getMethod( ..):获得指定方法。
         invoke(..):执行获得的方法。
         12.3.4：反射可以动态地创建对象、在运行是加载一个特定的类，通过反射技术可以找到一个类中定义了
                          什么方法，以及这些方法的参数和类型特征。同时，反射也破坏了封装性，并且运行速度较慢
                         要选择好合适的时机来使用。
第十三章：高级Swing
13.1：创建JTable
        创建JTable 的模型，可以从javax.swing.table.AbstractTableModel类扩展出一个类。并实现 getRowCount()
         getColumnCount()和getValue()三个方法，有时还要重写public String getColumnname(int col){}和public  
         class getColumnClass(int col){}(在这个方法中如果是返回基本数据类型一定要先转变成包装类型）。
        将创建好模型作为JTable的构造方法参数来创建JTable。
13.3：创建JTree
          基本模式是：public clss MyTree extends JFrame implements TreeSelectionListener{
                            public MyTree(){ 
                             DefaultMutableTreeNote dt = new Default..Note(Object o);
                              De....Note dt1 = new De...Note(Object o1);
                              .....
                              dt.add(dt1);
                               .....
                               DefaultTreeModel dtm = new De...Model(dt);
                               JTree tree = new JTree (dtm);
                             tree.addTreeSelectionListener(this);//注册侦听器
                           }
                        public void valueChanged(TreeSelectionEnent e){
                              .........
                        }
}
13.3：JOptionPane类：提供了许多对话框，全静态方法，直接调用。
第十四章：Java多线程编程
14.1：两种方法创建线程：通过扩展Thread类和实现Runnable接口，实现run()方法。其中实现了Runnable 的类还需要用Thread类包装。在主线程里调用start()方法后自动执行run()方法。
14.2：常用方法：
         Thread.currentThread():取得当前线程。
         sleep(long n):休眠n毫秒，只要中间没被切断，会自动唤醒。
 14.3：线程同步
         关键资源：同一时刻被多个线程使用，关键词：同步：synchronization。用此关健词修饰的代码同一时刻
    只能被一个线程调用，
      同步方法， 同步块。
14.4：等待通知机制
      相关方法：notify():随机唤醒一个等待线程。notifyAll():唤醒多个等待线程，优先级高的会被先执行。（多线程
   机制很复杂，所以线程的先后执行顺序不会完全按照优先级的高低来执行。）wait():一个线程调用此方法后，将进入等待池，处于临时阻塞状态，交出其所占用的资源监视器，并允许其他线程能够进入该资源。这种机制能更有效
 地利用资源。
14.5：线程之间的通信是通过PipedInputStream/PipedOutputStream来实现的。
14.6：其他几个方法：interrupt():中断线程；join()：两种形式，一种接受超时参数，另一种无限期等待。
第十五章：Java网络编程
15.1：TCP/IP网络分层：四层模型：应用层（http/ftp/pop/smtp...）——传输层（TCP/UDP）——网络层（IP）
——网络接口层;
 大体发送过程：
        待发送数据先被拆分成若干个数据包通过传输层加上TCP报头接着通过网络层加上IP报头，最后在网络接口层
 将IP地址转换成网卡物理地址后发送出去。
而接收过程刚好与之相反。
15.2：TCP通信：这是一种流式通信方式，能保证传输的准确，但传输速度相对较慢。
   大体模式是：
                 服务端：ServerSocker ss = new ServerSocket(port);//实例化一个服务器套接字并侦听port端口
                              Socket s = ss.accept();//接受并创建一个套接字对象
                              OutputStream os = s.getOutputStream;//从套接字中获得并构造流
                               InputStream is = s.getInputStream;
                              ............
               发送端：Socket s = new Socket(InetAddress ,port)//实例化一个套接字指名发送地址和端口并连接
                                  //构建流并通信。
15.3：UDP通信：这种方式速度快，但质量不能完全保证，无发送和接受端之分。
大体模式是：发送：DatagramSocket ds = new Da..Socket(port)
                              String str = "dsafas";
                               byte[ ] data = str.getBytes();
                               DatagramPacket dp = new DA..Packet(data,data.length);
                               ds.setPort(int);
                               ds.setSocketAddress(InetAddress);
                               ds.send(dp);
                      接受：DatagramSocket ds = new Da..Socket(port)
                                 byte[ ] data = new byte[1024];
                                DatagramPacket dp = new DA..Packet(data,data.length);
                                ds.receive(dp);
15.4:TCP和UDP通信的监听端口可以一样。
15.5：URL的格式：协议：主机名：端口：文件名
15.6：InetAddress：这个类没构造函数，用于封装计算机的IP地址和DNS。
第十六章：TDD测试驱动开发
16.1：使用Junit大体步骤：
         扩展TestCase类
         覆盖setUP()方法//初始化
          编写testXXX（）方法//这些方法一定要以test打头，用到了反射
            。。。
          覆盖tearDown()方法//测试结束回收资源。