JavaOOP总结

第一章：Java面向对象编程概述

Ø         抽象：我们在认识事物的时候只关注其中一部分而忽略次要部分。

Ø         面向对象：一种认识事物的方式，注重对事物整体的认知，更符合人类自然的思维习惯。

Ø         类：具有相同属性和行为的一组对象的集合。类是对象的抽象，对象是类的实例。类是一个模板，对象则是这个模板的具体实现。

Ø         面向对象的主要特征：继承、封装、多态。

Ø         继承的特点：具有层次结构，子类继承了父类的属性和方法。提高代码的重用性。

Ø         软件生命周期：分析、设计、编码、测试、实施和维护。



第二章：类

Ø         类 = 属性 + 行为

Ø         类是具有相同行为的一组对象的集合。

Ø         类是由数据和方法组成

Ø         属性：即成员变量（全局变量），定义在类里，并且在方法外。

Ø         属性的访问通过对象.（的）方式访问。

Ø         属性的特点：包含在对象之中，它的值发生变化，不会影响其他对象。

Ø         常量：作用1、见名知意  2、方便修改

Ø         常量在声明的同时必须进行初始化

Ø         静态类成员： static修饰的全局变量叫静态变量，也叫类变量。

类变量的值为所有对象所共享

引用类变成员（类变量和方法）不需要创建实例，可以通过className.variableName的形式直接引用。

静态变量的特点：1、唯一性  2、对象之外存放 2、加载时机在对象之前

Ø         静态变量是在类加载时产生，所以产生的时机在对象之前。静态方法产生于对象之前，所以不能直接访问非静态变量。

Ø         变量：命了名的内存空间，并且它的值可变化

Ø         垃圾回收站收集没有被变量指向的对象，回收堆内存中的对象。

Ø         构造方法特点：1、构造方法的名称必须要与类名相同

                  2、构造方法没有任何返回类型

Ø         构造方法的作用： 1、为对象分配内存

                     2、创建并初始化变量

                     3、初始化成员变量

                     4、返回引用

Ø         如果一个类里没有构造方法，系统会分配一个默认的无参构造方法。如果一个类有一个有参的构造方法，默认无参的构造方法就不存在。





第三章：继承

Ø         一个新类可以从现有的类中派生，这个过程称为类继承。现有类称为新类的父类（基类），新类称为现有类的子类（派生类）

Ø         继承可提高代码的重用性，使用extends关键字来实现。父类的方法和属性部分被子类的对象继承

Ø         如果一个类被申明成final修饰符，那么这个类就不能被继承了。

Ø       private修饰符的属性只能由本类调用，缺省成员可以由本类和同包内的其他类调用，protected成员可以由本类、同包内的其他类，以及不同包的子类访问。而public修饰符成员可以被所有的类访问。

Ø         父类的构造方法不能被它的子类继承.

Ø         子类对象构建时，会先去调用父类的构造方法。（没有父亲，哪来的儿子），并且子类需要通过父类构造方法的调用来完成从父类继承下来的属性初始化。

Ø         可以使用super()显式地调用父类的构造方法，如果父类构造方法有参数，也可以在括号中跟参数。

Ø         构造方法一旦有显示的申明，则隐式的构造方法就不存在了。这样，如果父类有显示、带参数的构造方法，则子类必须使用super(参数)显示的调用父类的构造方法

Ø         如果子类没有定义构造方法，系统会默认地添加一个无参的构造方法，并在第一句自动调用父类不带参数的构造方法super()。

Ø         在JAVA中，类的继承是单根继承，就是说一个类如果继承了另一个类之后，就不能再继承其他类了。

Ø         多态概念：允许一个父类变量引用子类，允许一个接口类型变量引用实现类对象。反过来却不行。具体表现为重载和重写。

Ø         使用instanceof的用于判断一个对象的实际类型，这个运算符用于判断一个对象是否是指定的类型。返回一个布尔值，是true表示匹配该类型，是false表示不匹配该类型。

Ø         子类重写父类的方法，访问修饰符必须和父类的访问修饰符相同，或比父类访问修饰符更大。

Ø         子类重写父类的方法后，在调用时优先调用子类的方法。子类没有该方法时，才去调用父类的方法。



第四章：接口

Ø         接口是抽象类的特例，在抽象类中的方法可以实现，也可以用抽象方法定义，但在接口中就只能是定义，不能有实现。

Ø         定义接口，使用关键字interface

Ø         接口里的方法都是public公有方法，即使不写，默认也是pubic的。其他的修饰符都无效。

Ø         接口定义出来，是要被类所实现的。定义一个类实现接口，就得实现接口里定义的所有的方法。使用关键字implements

Ø         接口是Java编程一项重要的技术，通过它可以实现多态，同时它也弥补了Java单一继承的不足。之前说到类是单根继承，一个类继承了另一个类之后，就不能继承其他类了。但现实生活中很多事物都同时拥有很多类的特性。为了解决这个问题，在JAVA中使用接口来进行描述这些事物不同的行为，在JAVA中一个类可以实现多个接口。这样的话，这个类就得实现每个接口所定义的方法。

Ø         接口中可以定义变量，但接口中的变量是公共的静态的常量。（public static final）

Ø         接口可以继承接口，继承之后会拥有父接口所定义的方法。集合框架JCF就是一个例子。Conllection是父接口，List和Set是子接口。接口可以是多继承。

Ø         一个类要实现一个接口，那么就得实现这个接口和这个接口父接口所定义的所有方法。

Ø         当一个类实现接口时，可以使用这个接口的变量去指向这个类的对象。

Ø         接口是在调用和实现中间加了一层。将调用和实现分离开来，增加程序的灵活性、扩展性和可维护性。



Ø         抽象类和接口区别：

1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现

4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

6、抽象方法只能申明，不能实现。abstract void abc();不能写成abstract void abc(){}。

7、抽象类里可以没有抽象方法

8、如果一个类里有抽象方法，那么这个类只能是抽象类

9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

10、接口可继承接口，并可多继承接口





第五章：异常处理

Ø         什么是异常：异常是程序正常执行过程中出现的不正常的情况。

Ø         异常捕获的顺序：当一个异常发生或抛出。那么正常的程序执行序列将被终止，程序将对异常进行处理，我们称之为抛出异常被捕获。JAVA中通过使用try-catch语句把可能抛出异常的语句包起来。

Ø       所有异常类的超类是Throwable。在Throwable下有两个子类，一个是Error，另一个是Exception。Error是错误，程序员无法控制，Exception是异常，程序员可以通过异常捕获加以控制。例如：电脑运行中中毒了，我们可以通过杀毒软件来处理，处理完了以后可以继续使用，这叫异常，我们可以控制。但电脑出现了蓝屏或死机的时候，我们就不能进行任何操作了。这就是错误，我们无法控制。

Ø         怎样捕获一个异常：

a、  把正常运行的代码放在try块里。

b、  如果程序中出现了异常就把异常抛出在catch中，如果catch中能捕获抛出的异常。那么就会进行处理。处理的代码写在catch块中。

try程序块里面的语句是按顺序执行的语句

当try程序块里面的语句抛出一个异常的时候，程序的控制转向了相匹配的catch程序块，catch程序块里面的语句被执行。

当异常发生后，程序执行将忽略try程序块中剩余的语句，继续执行程序块后面的语句。

如果在try程序块中没有抛出异常，那么catch块将被忽略。程序将继续执行try-catch下面的语句

Ø         如果有一块代码不管是否发生异常抛出都要被执行，我们使用关键字finally。这样的机制有助于我们进行系统资源的回收。



第六章：数组

Ø         JAVA中，数组是一个具有相同类型数值的索引集合  关键字：相同类型 索引 集合

Ø         数组应用的范围：方便我们对具有相同类型数值进行排列和值的操作

Ø         数组的2种声明方式：

              申明的方式有两种：int[]  array;       int  array[]

              在Java语言中, 一个数组是一个引用数据类型。也就是一个对象。所以在进行数组赋值时，也必须得使用new 修饰符，通过产生对象的方式为数组分配一个连续的内存空间。

       语法如下：

              int[]  array=new int[5];//将数组变量array指向一个分配了5个元素大小的数组对象。

Ø         数组特点

数组名称引用整个数组所占的整片内存空间

每个空间所包含的值称为数组元素

通过下标（索引）引用数组中的每一个元素，从下标从0开始

Ø         数组的长度length(public 修饰符)  注意和String的length()方法区别

              int array[]=new int[5];

              System.out.println(array.length);//求出数组长度

              结果是5。但最大下标是4，因为数组下标从零开始，最大下标等于数组长度减1

Ø         对于指定了长度的数组要初始化的化需要通过下标一个个的赋值很麻烦

              int  array[]  =new int[5];

       array[0]=9;array[1]=19;……

因此我们可以在声明数组的同时就初始化而不需要指定长度，长度默认是初始化元素的个数。元素之间使用逗号隔开

              String[]  array=new String[]{“41”, “62”, “35”,“54”};//数组长度为4

              String[]  array={“41”, “62”, “35”,“54”};

那么，注意这2种方式的区别：

在内存行为里的区别（指定长度的方式虽然在内存里开辟空间但是里面还没有放东西而另一种是开辟的同时往里面放入了值）

数组一旦创建，那么数组的长度就固定下来了，指定长度的方式可能会造成内存空间不足或空间浪费





第七章：Java类

Ø         java程序到底应该怎么样书写：

Ø         java程序结构的第一个步骤，注释的书写方式

//为单行注释，一次只能书写一行









Ø         java程序结构的第二个步骤，一个类使用时需要说明它的来历，java使用 import语句来进行类的说明

书写方式：import   javax.swing.Jframe(类的全路径)



Ø         java程序结构的第三个步骤， java语言的主体是由一个或多个类组成的，java语言的语法构成如下：

class <类名> {                            

                                  <类成员 声明>

                            }

注意：class前面的修饰符问题，如果是public 那么类名和文件名必须相同，在同一个文件里可以有多个类，但只能有一个类的修饰符是public，并且没有加上public修饰符的类在别的包里不能访问。

类是由数据和方法组成的。

Ø         一个程序有一个入口点。对JAVA而言，入口点是main方法。

Ø         创建一个对象时，需要给对象取一个名字，凡是自己可以取名字的地方都叫标识符。它是一个字符序列将用来命名类、对象、方法和属性。

Ø         标准类JoptionPane和Calendar 的使用。

JoptionPane为标准对话框

JOptionPane.showMessageDialog(null, "信息");//消息框

//输入框，返回字符串X为用户输入文本

String x=JOptionPane.showInputDialog(null, "请输入");

       *******************

Calendar 的使用(java.util.Calendar;)

获得Calendar对象

Calendar ca=Calendar.getInstance();

int year=ca.get(Calendar.YEAR);//获得年

int month=ca.get(Calendar.MONTH);//获得月

     int date=ca.get(Calendar.DATE);//获得日

     long  mill=ca.getTimeInMillis();//获得1970-01-01到ca表示日期的毫秒数

     日期格式化输出

java.util.Date类



Date date=ca.getTime();//获得日期对象

//定义格式化输出格式（java.text. SimpleDateFormat）

SimpleDateFormat dateFormat=new SimpleDateFormat("今天是YYYY年MM月dd日");

//按照指定格式，返回相应字符串信息

String dateInfo=dateFormat.format(date);

System.out.println(dateInfo);

//将字符串转为日期型

SimpleDateFormat dateFormat=new SimpleDateFormat("YYYY-MM-dd");

Date date=dateFormat.parse("1988-02-02");

第八章：集合类

Ø         集合：将多个对象合在一起变成一个统一的对象，然后通过这个统一的对象来实现对多个对象的管理（存储，检索，操作，传输数据）。在数组里要进行这样的操作，可以会写很多算法，但在集合里，只需要调用其中的方法就可以了。集合也可以对其中的元素进行操纵，增加、删除、更改。同时，我们可以把存储之后的数据用于传输。这体现了JAVA里的封装思想。我们利用集合的功能特点，把我们对底层数据的操作封装起来，这样可以让程序的主要精力放在业务处理上，而不是对底层数据的操作上。

Ø         集合和数组的区别：

1、 集合只能放置对象，数组中可以是对象数组，也可以是基本数据类型数组。

2、数组只能放置同一种数据类型，对于集合而言，里面元素可以是不同类型的元素

3、集合对象长度可以随着元素的多少发生变化，而数组一旦指定了容量，长度就不能发生改变。

4、集合中提供了很丰富的算法方法，而数组里的方法很有限。采用集合对数据的操纵会很容易。

Ø         在集合中可以放置任何数据类型的对象。在取出来的时候，都会是一个Object类型。

Ø         集合框架的结构：





Ø         集合的遍历有三种方式：



a、  for循环遍历（只适用于List接口类）

ArrayList<Stirng> list=new ArrayList<Stirng> ();

1ist.add(1);

              for(int I=0;I<list.size();I++){

                            String  temp=(String)list.get(i);

                            System.out.println(temp.length());

              }



b、  for-each循环遍历（JDK1.5版本，只能从头遍历到尾）

HashSet<String>  set=new   HashSet<String> ();

              for(String  temp:set){

                            System.out.println(temp.length());

              }



c、  使用迭代器循环遍历（只能从头遍历到尾）

HashSet set=new HashSet();

              Iterator it=set.iterator();//获得迭代器对象

            

              while(it.hasNext()){//判断是否有下一个元素，没有返回false

                     String temp=(String)it.next();//获得下一个元素对象

                     System.out.println(temp.length());

              }





第九章：Java的输入与输出

Ø         IO：

I：input 输入 通常做读取操作(将不同数据源的数据读入到内存中，也叫读取流)

O：output 输出通常做写入操作（将内存中的数据写入到不同的数据源，也叫写入流）

Ø         流是一个很形象的概念，当程序需要读取数据的时候，就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接.

Ø         类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流。这时候你就可以想象数据好像在这其中“流”动一样

Ø         我们使用JAVA的IO操作，必须要使用java.io里的类，所以在使用之前先要导入这个包

Ø         字节流

              抽象父类是 InputStream 和OutputStream

Ø         字符流

              抽象父类是 Reader 和 Writer

Ø         对象流

流的命名很有规律，一般是数据源加上流的名字，如：文件读取流就是FileInputStream，对象流就是ObjectInputStream。

Ø         不管是哪一种流，在数据传输的底层，还是以字节方式传输。

Ø         操作流的步骤：

建立流

执行操作

关闭流

Ø         对象序列化：

所谓对象序列化就是将对象的状态转换成字节流，以后可以通过这些值再生成相同状态的对象

不管是哪一种流，在传输时都是以字节方式进行传输，对象流也不例外，先将对象变成字节以方便传输，到达目地的的时候再还原成对象。这样的话，对象序列化极为重要，利用它可以实现我们把字节以一定的方式重新还原成对象。对于远程对象传输和对象的文件操作都必须将对象序列化。

Ø         如何实现序列化：

所有需要实现对象序列化的对象必须首先实现Serializable接口



第十章：Java GUI和Swing

package com;

import javax.swing.JFrame;

public class MyJFrame extends JFrame{

       public MyJFrame (){

              //设置窗体大小不可变

              This.setResizable(false);

              this.setTitle("我的窗体");

              //关闭窗体时，程序结束

              this.setDefaultCloseOperation(3);

              this.setSize(400,700);

              //放置最后一句

              this.setVisible(true);

}

       public static void main(String[] args) {

              new MyJFrame ();

       }

}



Ø         JFrame：带有标题和边框的顶级窗口。顶层容器，不能包含在其他容器中。



1.         获得窗体容器

2.         设置容器的布局管理器

3.         创建组件对象

4.         设置组件大小和位置

5.         将组件加入容器





第十一章：事件委托模型

Ø         委托事件模型处理步骤：

1.         建立事件源对象

2.         建立监听器对象

3.         建立源对象与监听器对象间的联系



第十二章：JavaBean与反射

1.         JavaBean必须包含一个无参的public构造方法

2.         属性必须都是私有的。

3.         JavaBean必须包含符合命名规范的get和set方法，以便访问JavaBean的属性。

4.         JavaBean应该是可序列化的。

5.         如果Bean有运行时的外观，就必须扩展java.awt.Component类。

Ø         反射的定义：

Java的反射机制是在编译并不确定是哪个类被加载了，而是在程序运行的时候才加载、探知、自审。使用在编译期并不知道的类。这样的特点就是反射。

Ø         要正确使用Java反射机制就得使用java.lang.Class这个类。它是Java反射机制的起源。当一个类被加载以后，Java虚拟机就会自动产生一个Class对象。通过这个Class对象我们就能获得加载到虚拟机当中这个Class对象对应的方法、成员以及构造方法的声明和定义等信息。

Ø         获得Class对象的方法

1、如果一个类的实例已经得到，你可以使用

       Class c = 对象名.getClass();

      例： TextField t = new TextField();

              Class c = t.getClass();

              Class s = c.getSuperclass();

2、如果你在编译期知道类的名字，你可以使用如下的方法

Class c = java.awt.Button.class;
或者

         Class c = Integer.TYPE;

3、如果类名在编译期不知道, 但是在运行期可以获得, 你可以使用下面的方

Class c = Class.forName(strg);



第十三章：高级Swing

Ø        JTable类是正真面向显示的对象，另有一个名为模型的不可见类负责处理底层数据。

Ø        使用JOotionPane()方法，能快速建立并定制几种不同类型的标准对话框。

Ø        JOotionPane类可以使用showXXXDialog()的方法来显示不同类型的对话框。



第十四章：Java多线程编程

Ø         多任务处理有两种类型：

   1、基于进程

   2、基于线程

Ø         进程指一种“自包容”的运行程序，有自己的地址空间。

Ø         线程是进程内部单一的一个顺序控制流，它决定程序执行的顺序。

Ø         基于进程的特点是允许计算机同时运行两个或者更多的程序。

Ø         基于线程所需开销更少

   - 在多任务中，各个进程需要分配他们自己独立的地址空间。

   - 多个线程可共享相同的地址空间并且共同分享同一进程。

Ø         wait()和sleep的区别：

  - wait()在Object里定义。sleep是在Thread线程类里定义。

  - wait()只能放在同步方法或同步块中，而sleep任何地方都可以放置。

  - wait()会释放对象锁，而sleep不会释放对象锁。

  - wait()需要其他线程唤醒才能继续运行，而sleep是休眠一段时间后自动恢复运行。

Ø         创建线程可以继承Thread类或者实现Runnable接口两种方法。



第十五章：Java网络编程

Ø         服务器端的主要代码及知识点：

//建立服务器套接字，并开放8888端口

ServerSocket serverSocket = new ServerSocket（8888）；

//监听8888端口，如果客户端有请求到达，则返回一个Socket对象，而这个Socket对象包括了客户端所有信

//息（IP，端口，消息体），监听端口，处于阻塞状态

Socket socket = ServerSocket.accept()

//从套接字里得到输入流对象，这个对象里就有数据。

InputStream in = socket.getInputStream();

//将字节流转化为字符流

BufferedReader br = new BufferedReader(new InputStreamReader(in));

//从流中读取信息

String info = br.readLine();

Ø         客户端中Socket对象是直接new出来的

//指定服务器地址和端口号

Socket socket = new Socket("127.0.0.1", 8888);

//从Socket对象中得到输出流

OutputStream out = this.socket.getOutputStream();

//将字节流转化为字符流

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));

   bw.write("你好！");

//换行表示数据结束符
   bw.newLine();

//刷新流
   bw.flush();