java基础

 第一章  java概述

1.      Java语言的起源与发展：1996年——1.0版本

2.      java程序分类：

v        java  Applaction(java应用程序)：由main方法，可以独立执行

v        java  Applact（java小应用程序）

3.      计算机的发展：

最早的计算机：冯诺依曼机

计算机的位数（16/32/64）：一次能处理的数据位数

4.      命令窗口：

磁盘切换：盘符名：（d:）

查看该文件夹下所有文件： dir

编译： javac + **.java   例如：javac test.java

运行： java +文件名          java test

Javac.exe : 将 .java 文件编译生成 .class 文件（又名字节码/二进制文件）

Java.exe : 解释器，将 .class 文件执行

5.      类： java 程序以类为单位

5.1 公共类： 一个程序中可以有多个类，但是只有一个公共类，且文件名称必须与公共类名称相同

5.2 主类： 一个类中包含一个主方法的类称为主类；一段代码中，主类可以有多个；程序中有多少个类，编译后生成多少个 .class 文件

例如：

 

编译生成两个 .class 文件 Demo.class    Test2.class

 

5.3   两个主类同时显示：方法的调用

有参数：Demo.main(at)    （上图）

       无参数：

      

5.4   类名的命名规则：（类，方法，变量）

²       符合标示符的定义

²       见名知意

²       类名首字母大写，若有多个单词，则后面的每个单词首字母大写，变量的方法名小写，有多个时后面的首字母大写，常量名称所有字母大写

6.      变量： 相对于常量，在程序运行过程中值可以改变的量

6.1 计算机内存中的一个能存储规定数据类型的存储单元，在程序运行过程中存储的量是可以改变的

6.2 变量的命名： 首字母为小写字母，有实际意义，多个单词链接时后面的单词首字母大写

6.3 变量声明： 类型名  变量名1 [ =初值1 ] [ ,变量名2 ]

变量需先声明后使用

例：  int a;       String name;

       6.4 变量的三要素;    类型   名称  作用域

       6.4 根据变量的位置不同，变量可以分为两种：

v       局部变量：在方法或语句块中声明的变量，局部变量未初始化前不能参与运算，没有默认值

Ø        语句块：指复合语句，即：由一对大括号将一个或多个语句括起来组成的整体（在嵌套的语句块中，变量不能重复定义）

Ø        局部变量的作用域：从声明处开始到方法的结束处（语句块的结束）

v       成员（实例）变量：在类体中声明的变量，若没有赋值，则其有相应的默认值，可以参与运算（域，字段）

7.      常量：值变化的量（常量名称所有字母大写）

7.1  字面常量：所见即为真，看见什么就是什么

7.2  符号常量(最终变量)：用一个符号代替一个字面常量，这个标示符符号就是符号常量

7.2.1  符号常量的声明：

格式：final  类型名 符号常量名=值；

如： final  double  PI = 3.14;

7.2.2         什么情况下定义符号常量：在一个项目中，某一个或多个数据反复使用，且使用过程中其值保持不变，则将其定义为符号常量

7.2.3使用符号常量的好处：

7.1.1         提高程序的稳定性

7.1.2         提高维护效率

注：符号常量名称通常用大写字母表示

 

8        返回值：

8.1 方法名前面为 void 时，表示只完成任务，不返回任何值

当方法名前面不是 void 时，表示完成任务，并且最后的结果返回，在调用方法中要有一个变量用来接收返回的结果

9. 数组：一组变量的集合，具有相同的名称、类型

 

第二章

9/24

1.        注释：对程序中文字进行说明的文字

u      单行注释：//

u      多行注释：/*    */

u      文档型注释： /**     */

多行注释和文档型注释的区别：多行注释在 javadoc.exe 运行后生成的( .html )文档中注释的内容不显示，而文档型注释有文字说明

使用注释应注意的问题：

ü        单行内容只能在一行

ü        多行注释或文档型注释不可以嵌套使用

ü        只存在于源文件中，不会在编译后进入字节码（.class）文件

2.         标识符：以数字、字母、下划线、$ 组成，且不能以数字开头的字符系列，汉字可以作为标示符，但不常用（在不支持汉字系统的机器上会报错）

作用：作为方法、变量、类命名时的规则来使用，即方法、变量、类的名称必须符合标识符的定义，且不能是关键字

3.  关键字：在 java 语句中将某些单词或字符符号保留下来并赋予特定的含义作为特殊用途

例如：public    int   class   void 等60个

       注：true   flase 是保留字而非关键字

4.       数据类型： 基本类型和引用类型

u       存在原因：计算机世界中，根据需要分为不同的种类，以便于计算机识别他，应用它

u      基本类型：共三类，八种

²       数值型：byte  short int  long  float double

Ø        字节型（byte）：1B   [-128 ~ 127 ]                     2^7

Ø        短整型（short）： 2B   [ -32768 ~32767 ]               2^16

Ø        整型（int）： 4B  [  -2147483648 ~ 2147483647 ]        2^31

Ø        长整型（long）：8B  [-2^63 ~ 2^63  ]

Ø        单精度型（float）：4B  [  -2147483648 ~ 2147483647 ]

Ø        双精度型（double）：8B   [-2^63 ~ 2^63  ]

²       字符型（文本型）：char

Ø        字符型（char）：2B  范围 [ 0 ~ 66636]

²       逻辑型（布尔型）：boolean

Ø        逻辑型（布尔型）：true   flase

u      引用类型：数组    类   接口

5.       转义字符：该字符不再表示它的本意，表示一种特殊的含义，在java 语言中，以“ \ ”开头，后跟一个字符组成

Ø        \r   回车 即：光标回到本行的行头，若后面还有，则输出时会覆盖前面输出的内容

如：System.out.println(“ABCDEF\r123”)

       输出结果为：123DEF

Ø        \n  换行  即：光标换到下一行

Ø        \b  退格  即：光标左移一位

如：System.out.println(“ABCDEF\r123”)

       输出结果为：ABCDE123

Ø        \t  制表位  即：Tab键  将光标跳到下个制表位

Ø        \\   表示\  右斜杠本身

Ø        \”   表示 ”  (双引号)    字符串的边界符号

Ø        \’   表示 ‘  (单引号)     字符的边界符号  ‘A’

 

 

9/26

1.        运算符：

1)       算术运算符：+  -  *  /  %

v       +

ü        加 如：a+b

ü        连接 如：”ABC”+123  ABC123

ü        正号  +6

v         -        

ü        减  如：a-b

ü        正号  +6

v         *        

ü        乘   如：a*b

ü        通配符：abc*.Java(开头为abc的java文件)

v       /   除  如：a/b(当除号左右两边均为整数时，结果为整数/商)

v       %  取余（取模） 如：a%b   (取a/b得余数)

2)       赋值运算符：=

格式：变量= 表达式

规则：先计算表达式的值，再将表达式的值赋给左边的变量存储

注：赋值运算符左边只能是变量，不可以是常量或表达式

       如：6 = 3+1;error a+b = 2;//error

 

3)       递增、递减（自增、自减）运算符：++ 和 –

v       自增（++）: a++ 相当于a=a+1;

ü        a++      先使用，后加1

ü        ++a     先加1，后使用

v       自减（--）：a—相当于a=a-1

ü        a--       先使用，后减1

ü        --a     先减1，后使用

      趣味思考： int a = 2;   则 a = a++ ; 之后，a 是多少？

                            inta = 2;  则 a = a++ + a++ + a++ ; 之后，a 是多少？

4)       关系运算符：>  <  >= <=  ==  != instanceof (属于)

注：运算结果为逻辑值

       若有两个符号组成，则符号之间不能有空格

5)       逻辑运算符： !           &    |      ^     &&       ||

v        !（非）：

格式：!a

规则：a为true时，结果为false，反之，结果为true

v        &（与）

格式：a&b

规则：a和b均为true时，结果为true，反之，结果为false

v        |（或）

格式：a|c

规则：a和b有一个为true时，结果为true

v        ^（异或）

格式：a^b

规则：a和b相同时，异或为假，不同为真

v        &&（短路与）

格式：a&&b

规则：当&&左边为假时，右边不再运算

优点：提高运算效率，缩短判断时间

v        ||（短路或）

格式：a||b

规则：当||左边为真时，右边不再运算

优点：提高运算效率，缩短判断时间

6)       条件运算符：  ?  :

格式：变量=条件 ？ 表达式1 ：表达式2

规则：先判断条件，若条件成立，计算表达式1的值，否则计算表达式2的值，将该值赋给左边的变量存储

       如：max = a>b ? a : b; 

7)       扩展的赋值运算符：+=         -=   *=       ,/=       %=

组成：由赋值运算符和其他运算符组合而成

格式（特例）：a*=3+6; —— a=a*(3+6)

规则：先计算扩展的赋值运算的右边的表达式，再用左边的变量与右边计算后的进行相应的运算，最后将运算结果赋给左边变量存储

8)       位运算符：& |     ^    ~   >>   >>>     <<

²       &（按位与）

格式：a&b

规则：对应位均为1时，则为1，反之为0

²       |（按位或）

格式：a|b

规则：对应位有1时，则为1，反之为0

²       ^（按位异或）

格式：a^b

规则：相同为0 ，不同位1

²       ~（按位取反）

格式：~a

规则：0变1，1变0

²       <<（按位左移）

格式：a<<b

规则：每左移1位，扩大1倍

²       >>（按位右移）

格式：a>>b

规则：每右移一位，缩小一半

²       >>>（无符号按位右移）

9/26

1.        类型转换：

1)       当赋值运算符的 左右两边 数据类型不致时，需要怎样处理？

T       类型的自动转换；    

T       类型的强制转换。

2)       类型的自动转换是在什么情况下：

              将小类型的数据赋给大类型的变量。

       如图。

 

       另外:一个整数在不超出byte、short、char范围时，则可直接赋给它们的变量。

3)       类型的强制转换是在什么情况进行？

答：将大类型的数据赋给小类型的变量，则需要强制转换。

              强制转换的格式为:   (类型名)(数据);

              例如:   byte b1 = (byte)(200+100);

              强制转换也称之为造型

             

              练习: 编写一个程序，来校验八种基本类型数据之间的自动转换和强制转换.

             

4)       一个表达式中有不同类型的数据时，则表达式的最终类型如何确定？

       四个原则：

%       当表达式中有double型时，则表达式的最终类型为double型。

%       当表达式中没有double，而float型时，则表达式最终为float型。

%       当表达式中既没有double，也没有float；而有long型时，则表达式的最终类型       为long型。

%       当表达式中既没有double和float，也没有long型时，则表达式的最终类型为int型。

2.        字符串   

1)       在java语言中，字符串由专家给定的 java.lang.String类来管理。

因此，字符串属于引用类型。一个字符串就是一个实例（对象）。                  

       注意:一对双引号，其中没有任何字。如: "" ，则它表示一个长度为0的串。

       注意:  String str = null;   其中null，表示字符串不存在。               

2)       字符串的特性：

v        字符串属于引用类型的数据，一个字符串就是一个对象。         

v        在字符串中，每一个字符都拥有一个索引号（位置编号），它从零开始。

                 例如: "ABCDEFG"  ，其中 'A' 的索引号为0，而 'E' 的索引号为4     

v        在java语言中，字符串是不变的，是可以共享的。                    

v        字符串还拥有许多方法，用来解决一些实际问题。

               例如: length() 用来求串的长度。                           

               因此，我们重点学习它的常用方法。                        

              charAt(n); 用来获取第n个位置上的字符

              substring(n, m); 用来获取串中第n至m-1位置上的字符并组成一个子串。

              substring(n);   用来获取串中第n至末尾位置上的所有字符并组成一个子串。

indexOf(s1); 在当前串中查找s1对应的串，若存在，则反馈它出现的位置编号；若不存在，则反馈一个负数。

              indexOf(s1, n); 在当前串中从第n个位置开始查找s1对应的串 若存在，则反馈它出现的位置编号；若不存在，则反馈一个负数。                                              

              replace(ch1, ch2); 将当前串中指定的字符ch1替换成ch2并生成一个新串。

              replace( s1, s2 ); 将当前串中指定的子串s1替换成s2串并生成一个新串。       

              startsWith(s1);        判断当前串是否为s1子串开头。

              endsWith(s1); 判断当前串是否为s1结尾。

              toLowerCase(); 将当前串中的大写字母转换成小写的并生成一个新串。

              toUpperCase(); 将当前串中的小写字母转换成大写的并生成一个新串。           

              trim();将当前串前后的空格删除并生成一个新串。

3)       判断字符串相等？

²       s1.equals(s2);  判断s1和s2对应的串是否相等？

²       s1.equalsIgnoreCase(s2);  在不区分字母大小写情况下，判断两个串是否相等。                           

4)       基本类型的数据 与 字符串在内存中的分配情况？

 

 

结论:判断基本类型的数据是否相等用 ==

               而判断字符串是否相等用 方法: equals() 和 equalsIgnoreCase() 。

注意: 若用== 去判断字符串相等，实质是判断它们的地址是否相等。

3.        三的流程控制结构（任何计算机语言都有的）：

程序员解决问题的过程和步骤可由程序员掌控的现象

以下三种结构相互配合使用，可解决任何问题

3.1         顺序结构：就是按照语句的书写顺序执行（语句怎么执行，就怎么书写）。

3.2         选择结构：if语句   switch 语句

3.2.1     if 语句

²       单项的if语句：if( 条件) { 语句块; }

²       双向的if 语句：if( 条件) { 语句块1; } else { 语句块2 ;}

²       多向的if 语句：if( 条件1) {语句块1; }else if( 条件2 ){ 语句块2; }……}else if( 条件n ){语句块n;}else{语句块m; }

规则:  当条件1成立时，则做语句块1；之后，结束整个if而往下走。当条件1不成立，则判断条件2，若条件2成立，则做语句块2；之后，结束整个if而往下走。依次类推下，当所有条件均不成立，则做语句块m，之后，结束整个if而往下走。

注意：1.  在使用if语句时，尽量按标准方式书写。

         2.  if语句中，其一对大括中只有一个语句时，则这一对大括号可以省略。

                            例如:  if(a > b ){

                                                 max= a;

                                      }else{

                                               max= b;

                                      }

                                     

                                      可写成

                                      if( a > b )

                                               max= a;

                                      else

                                               max= b;

                                              

         3.  if语句可以嵌套使用。即：一个if语句中可以包含另一个if语句   

                       4.  if语句中，else不能单独使用，它必须与if配对使用。

配对原则：else 总是与最近的未配对的if配对，且最近的if没有被一对大括号隔离开来。

思考:  已知三个整数 a, b, c；用if语句实现这三个整数的排序（由小到大排）.依次类推，四个整数或五个整数，如何通过if语句排序？即：通过此练习找出排序的规律。

3.3.2     多分支选择结构的switch语句

T       格式:   

switch( 表达式 ){              

case 值1 : 语句系列1;  [break;]

                     case值2 : 语句系列2;  [break;]

                     case值3 : 语句系列3;  [break;]

                            ......

               case 值n: 语句系列n ;  [break;]

                     [default: 语句系列m ; ]                                               

                     }

                                         

T       规则:  先计算表达式的值，然后找到与表达式的值对应的 case，做它后面语句系列，当遇到 break; 语句时，则结束整个switch语句而往下走； 若遇不到 break; 语句时，则继承做下面的语句系列，当遇到 break; 就会结束，遇不到会继续往下直到switch的 "}" 而结束。另外，当找不到与表达式的值对应的case 且switch语句中有 default时，则做default对应的语句系列m，之后，结束整个switch。

注意:

a) 表达式的值，其类型必须是 byte或short或int或char型。

b) case后值1、值2、值3、...、值n，它们一定是对应的byte或short或int或char型常量。 它们不可变量，也不可是带变量的表达式。

c) 当多个连续的case，其语句系列一致，则可以省略前n-1，留下第n个。

3.3         循环结构的语句有三种 ：

3.3.2     当循环（或称之为while循环）

格式:

              while(条件 ){

                     循环体;

              }    

       规则:  先判断条件，若条件成立，则做循环体一次；再返回去继续判断条件，若条件仍然成立，则继续执行循环体；依次类推下去，直到条件为假而结束整个while循环。

案例:  通过案例理解为什么要循环，循环如何进行？

       输出一个5

       输出5个5

       输出10个5  ===>>>> 思想： 让同一个语句反复执行10次

       解决实际问题： 求 1 + 2 + 3 + ... + 100 = 值

分析:            

第一个数:  1

       第二个数:  2

       第三个数:  3

       下一个数是： 上一个数再加1 。

       要将它们累加起来。

       最后加到 100 就结束了。

练习1：首先理解并掌握此案例，需要一边理解一边书写一边调试。

练习2：用while循环，同时求出 [1 , 100]内奇、偶的分别累加之和并显示它们。

练习3：编写一个方法求[ 1 ,n ] 范围内整数之和。

3.3.2     直到循环(也称do --- while  循环)

格式:

do {

循环体;

      } while( 条件) ;         

规则:先做循环体一次， 再判断条件，若条件成立，则返回去继续执行循环体；之后，再来判断条件，若条件仍然成立，则返回去继续执行循环体；依次下去，直到条件为假而结束整个do -- while循环。

案例:通过while循环演变为 do -- while循环来掌握do--while循环。

1.1.1     从什么到什么循环（也称为 for循环）

       格式: 

       for(表达式1; 表达式2; 表达式3 ){

                     循环体;

       }

规则:先做表达式1，接着去判断表达式2的值是否为true；若为true，则去执行循环体；之后，再去做表达式3；然后，返回到表达2处，继续判断表达式2的值是否为true，若仍然为true，则继续执行循环体；依次下去，直到表达式2的值为false而结束整个for循环。   

案例:求 1 + 2 + 3 + ... + 100 =

分析发现:它是 1 到100 的累加。每个数据是它前一个数再加1。

3.4         要实现键盘输入三个步骤：

1) 在程序的开始写上:  import java.util.Scanner;  语句。

含义: 导入Scanner类。

2)  在方法中写上:  Scanner  sc = newScanner(System.in);

              含义: 创建一个Scanner类的对象，实现键盘输入功能

       3)  通过sc调用其相应的方法实现数据的输入。

              如:  intx = sc.nextInt();  //用来输入一个整数。

9/27

专家给定数学类: Math

1）它来源于java.lang.Math;

       2）它为程序提供了许多常用的数据函数

              （注：在java语言中，把这些函数称之为方法）及数学常量。

              abs( n );  求n的绝对值

              sqrt( n ); 求n的平方根, 反馈结果的类型为double型。

              pow( x , y ) ; 求x的y次方 , 反馈的结果为double型。

              random(); 产生一个[ 0 , 1 ) 范围的随机数。

              round( x ); 对x进行四舍五入反馈一个long型整数。

              PI 是java语言中规定的圆周率常量。

       思考1：产生一个 [-100 , 100] 范围的随机整数

                     产生一个 [ 16 , 789 ] 范围的随机整数

                     产生一个 (0, 100) 范围且四舍五入保留两位小数的随机数。

 

 

 

 

10/8

1.       概念：

1)       对象：实实在在存在的，看的见，摸得着的实体；

2)       面向对象思想(OOA）：在解决问题是可以将一个大的实物分解为小的对象，分析这些对象的属性，方法，进而解决问题的思想

3)       面向对象的程序设计(OOP)：把对象的特征( 属性)和行为（能力）作为一段单独的代码封装成一个类

2.       类：

2.1         类的三大特性：

v        封装性：把业务的数据和处理数据的方法封装起来成一个类，保证了数据的安全性和高效性

v        继承性

v        多态性

v        （抽象性）

2.2  类的框架结构（类由哪几部分组成）？

v        实例变量（成员变量，域，属性，字段）：

v        构造器：实现对象的创建并完成对象的初始化 

格式：new + 构造器；

v        设定器（调节器）：用来设置或修改对象的属性值

v        访问器：获取对象的属性值

v        功能方法：体现对象的能力和价值

2.3  类的应用（通过类去创建对象，再通过对象去解决实际问题）？

注：

%       在java语言中，任何一个类至少有一个构造器，当一个类中没有人为的构造器时，系统会自动生成一个默认的构造器（没有参数的构造器）。

%       在同一位置下，类名不允许重复 è>>> 解决办法：打包（类名唯一性）

 

3.       方法：具有一段独立功能的代码封装起来构成的整体

3.1         方法的组成结构如下：方法头部和 方法体

             [public | private ] [static] [final]  返回值的类型  方法名(形式参数列表 ){

                           方法体;              

}

             方法头部反应了方法的特性，而方法体反应了方法解决问题的过程。

[public |private] : 表明了方法的访问权限。 

public 表明方法是公开，可被外界调用。

private 表明方法是私有的，只能在本类中使用。

既没有public，也没有private，则表明方法是一个缺省访问权限。这样的方法只在同一个位置上的类可 以调用它。

[static]: 表明方法是否为静态的。

当方法头部有 static 时，表明方法是静态的。静态的方法属于类，它往往通过类名去访问。如:  类名.静态方法。  再如:Math.pow( 5, 3 );

              当方法头部没有static时，表明方法是非静态的。非静态的方法属于对象，只有对象存在时，这样的方法才存在。

                     因此，非静态的方法必须通过对象才能调用。

                    如：intre = p1.add( a , b );（Test1.java中的）

T         [final]: 表明方法是否为最终的。 （后述）

 

T         返回值的类型：表明方法是否有返回值，若有返回值，返回的值属性什么类型。

             当返回值的类型为:  void 时，则表明方法只完成任务，不反馈结果。

      当返回值的类型不是 void ，而其它基本类型名或引用类型名时，表明方法不仅完成任务，而且最后需要将结果通过 " return 结果; " 此语句来反馈。

  5) 方法名， 往往需要符合标识符的规则，往往需要做到见名知义。

  6) 形式参数列表， 表示方法在调用时，是否需要数据。

       当形式参数列表不存在时，即：方法的小括号中是空的， 则表明方法在调用时，不需要数据。String  sn = this.getName();

      当形式参数列表存在时，即：方法的小括号中有类型名，变量名等多个这样的参数， 则说明，方法在调用时，必须给相应的数据。

             this.add(8, 9, 10 );

 7) 在调用方法时，方法小括中的数据称之为 实际参数。

例如: this.add( 8 , 9 , 10 );  其中小括内的数据称之为实际参数。    

       注意:实际参数的个数，类型，顺序 必须与 形式参数的个数，类型，顺序一致。否则，出错。

 4、在一个类中，可以有多个方法，还可以有多个同名的方法，然而，同名的方法必须要求其形式参数不同。

即:在一个类中，方法是可以重载的？

 1）什么是方法的重载？

方法名相同，而方法的形式参数 的类型或个数或顺序不一样。

 2）在调用重载的方法时，是如何区分的？

根据给定的实际参数（类型、个数、顺序）与形式参数（类型、个数、顺序）的对应关系来区分。

3) 方法的重载有何好处？ 或者说，在什么情况下将多个方法定义为重载的方法？

 5、构造器是方法， 由于同一个类中方法可以重载，那么，构造器也可以重载吧。

也就是说： 同一个类中可以有多个构造器。

 

 

 

 

 

10/12

1          Java常用类

1.1         8种基本类型

1.1.1     8种基本类型对应的封装类：

                    byte  ===>>>>  Byte

                    short  ===>>>>  Short

                    int     ===>>>>  Integer

                    long ===>>>>  Long

        

                    float===>>>>  Float

                    double==>>>>  Double

        

                    char  ===>>>>  Character

                     boolean ==>>>  Boolean

      

1.1.2     基本类型，提供其封装类的目的是什么？

a)        将基本类型的数据 变成对象 ，之后，它就拥有相应的方法。

b)       有了相应方法，就可以解决一些实际问题。 如: 将156转换成二进制数等。

c)        为基本类型的数据提供相应的封装类，之后，则可以管理基本类型的特性。如：某种类型的数据范围。

                           

1.1.3     下面以 int 的封装类Integer 为例理解 并掌握基本类型封装类。

                     从jdk5开始，新增了一个特性:

                     1) 重点掌握:  自动装箱 和 自动拆箱。

u        自动装箱： 将基本类型的数据直接赋给相应的对象变量。

如: Integer  jObj =  300;  è 300会自动封装成Integer类的对象。

u        自动拆箱：将iObj对应对象中的数据自动取出，再赋给变量x存放 。

                                          intx = iObj.intValue(); //从iObj对应对象中获取它的整数。

x = iObj;//自动拆箱的

                     2) 将纯数字字符串还原为数字本身。

1.2         可变字符串

1.2.1     不变字符串：由String 类来管理，由一对双引号将多个字符括起来组成一个字符系列，如：“ABCDEF”

1.2.2     可变字符串：由 StringBuffer或StringBuilder类来管理，他先提供一个容器，里面可以存放大量的字符，这些字符可以随时删除某个或某些，也可以添加，插入，修改操作，从而这个字符串产生变化

1.2.3     可变字符串和不变字符串的区别：可变字符串比不变字符串多些方法（插入，删除，修改，替换等操作）

注意:StringBuffer 和 StringBuilder 两个类的功能一样，但，后者处理效率高于前者。建议优先使用后者。

1.3         Date类的应用。

1.3.1     Date 类来自于 java.util.Date;  因此，使用时必须用 import java.util.Date; 导入。

1.3.2     Date 类的特性： 类 Date 表示特定的瞬间，精确到毫秒。即：用来管理一个确定的日期和时间。

1.3.3     它常用的构造器为:  

ü        默认构造Date() ，它所构造的对象与系统时钟一致。

ü        带longtime 参数的构造器。它所构造的对象是你指的时间。

         注意：在java语言中，基准日期时间为:1970-1-1 00:00:00

                    另外，它以毫秒为单位。1秒== 1000毫秒。

1.3.4     它的常用方法：

         long　getTime(); 

 

         boolean d1.after(d2); //d1在d2之后吗

         boolean d1.before( d2 ); //d1在d2之前吗。

 

         d1.equals(d2);

         d1.compareTo(d2);

2          日期和时间的格式化

2.1         通过printf() 格式化方法来实现。

        使用格式为  System.out.printf("信息<%tx>"  , 数据);

注意:在日期与时间的格式化中，常用的格式控制符(它通常用%t 开关，后跟一个字符组成)如下：  

              %tF 用来控制日期

              %tT 用来控制时间

              %tA 用来控制星期

                            ...

2.2         通过String类有一个特殊方法: format()，它与 printf()的格式化形式完全一样；只不过String.format(); 格式化后得到是一个字符串，而printf()是将结果打印出去。

2.3         DateFormat类来实现日期与时间的格式化。

²       DateFormat类来自于 java.text.DateFormat;

²       DateFormat类 通常用来来实现 日期与时间的格式化

²       DateFormat类 还可以将 日期型字符串 还原为 Date 类的对象。

        注意:它是一个抽象类，不能创建其对象。

2.4         SimpleDateFormat类来实现日期与时间的格式化。

u       来源于  java.text.SimpleDateForomat;

u       它属于DateFormat 类的子类( 儿子)。

u       作用：

²       实现日期和时间的格式化。与 DateFormat 父类不同地方是： 它比父类要灵活地多。

²       将日期或时间型字符串还原为 Date 类的对象。（继承父类的方法）

 

10/14 星期一

1          数组

1.1         数组的定义：

1.2         特性：

1.3         申明与创建

1.4         数组元素的访问

1.5         引用类型的引用：（）

1.6         数组的复制

1.7         针对一位数组的工具类：Arrays

1)        来源于java.util.Arrays

2)        为了提高一维数组的操作的效率，它提供了许多静态的方法。

                     toString( a ) ;  将数组a的所有元素值组成一个字符串。

sort( a );  对数组a进行由小到大排序。

 

equals(a, b); 判断数组a与数组b完全相等吗？(注意:个数一样，对应位上的元素值一样)

 

binarySearch(a, key); 采用二分查找法，在数组a中查找key元素；若存在，则反馈它的位置编号; 若不存在，则反馈一个负数。

2          命令行：

3          java中随机数的产生：两种方式

3.1         通过Math数学类的 random()方法来产生。

3.2         通过java.util.Random类来产生。

注意:在使用 Random类的默认构造器创建一个随机对象，并通过它来产生随机数，则每次的数一般不同。也就是说，这个默认构造器产创建对象，其产生随机数的种子是以时间为种子。

另外，若使用Random(long zz) 构造器创建的多个对象，且给定种子一样，则这几对象所产生随机数是同步，即：一样。

 

10/15 星期二

1          多维数组：

1.1         Java语言中的多维数组？

       在某个数组中，数组的元素拥有两个或两个以上的索引号。它的表现形式如:  a[1][3]

1.2         以二维数组为例来理解并掌握多维数组？

1.2.1     二维数组中，每个元素均拥有两个索引号；每个索引号都是从0开始。

1.2.2     在java语言中，二维数组可以是不规则的。即：每一行拥有的元素个数可以不一样。

1.2.3     在java语言中，实质没有多维数组。多维数组实质是多个一维数组组成的。

1.2.4     二维数组也需要先声明，再创建，最后应用。 

                    注意：在声明时不能指定其下标。例如： int[3][5]  a;（错误的）

                    注意: 在创建二维数组时，可以先创建其行数，再创建每一行的元素个数。

例如: int[][] a = new int[3][]; //创建了一个具有三行的二维数组，而每一行的元素个数待定。

                     a[0] = new int[5]; //第0行创建了具有5个元素的一维数组。

                    注意: 在创建二维数组（或多维数组）时，不可先创建列数，再创建行数。

                            例如: int[][] a = new int[][5]; //error

1.2.5     对二维数组进行访问：往往通过 嵌套的for循环来实现。

1.2.6     对二维数组进行初始化：同上

1.2.7     二维数组也可通过直接赋值的方式来创建。

1.2.8     不规则的二维数组如何创建：

ü        先创建其行数;

ü        再为每一行创建其元素个数。

在创建一维数组和二维数组时必须给其参数,即int a[] = new int[5];

       Int[][]a = new int[7][];/       Int[][] a = newint[7][4];

Variable must provide either dimensionexpressions or an array initializer变量必须提供维度表达式或数组初始化

 

 

2          正则表达式：

2.1         String类中特有的方法: split() 及其应用。

1)        通过掌握的方法结构发现： split()方法用来接收 一个字符串，处理后，反馈一个字符串数组。

2)        功能:将一个串按照给定的分隔符进行分隔成多个子串。即： 打散（把一个串打散成多个子串）。

3)        特点:给定分隔是一个正则表达式。即：分隔符可具有通配性。

2.2         什么叫正则表达 ？

2.2.1     正则表达就是一个字符串，是一个由普通字符、预定义字和量词组成的字符系列。

 

2.2.2     正则表达式的作用：正则表达式用来实现字符串的匹配判断 。

2.3         正则表达式中常用的预定义字符和量词分别如下：

                    \s     表示空格

                    \S    表示非空格

                    \d    表示数字 ，相当于 [0-9]

                    \D    表示非数字

                    \w    表示一个单字字符。即：要么为字母，要么为数字，要么为下划。

                           相当于[a-zA-Z_0-9]

        

                    .   表示任意字符。   

                   

                    ...等等。

                    注意: 普通字符通常用一对[]括起来。

                    注意: 一对[]中括号括起来的表示一个字符的集合。

        

                    量词，用来表示数量。常用的如下：

                    *            表示0个或0个以上。

                    +            表示1个或1个以上。

                    ?             表示0个或1个。

                    {n}         表示正好n个。

                    {n,m}     表示至少n个，最多m个。

                    {n,} 表示至少n个，最多不限。

        

                    |      表示其左右两可选一边的。即：要么是它左边，要么是它右边。

                     ^a-z      非a-z范围的字符

                          

2.4         正则表达式的应用？

       1) 通过String类提供的 matches(regex)方法实现字符串与正则表达的匹配判断。

2)  通过Pattern类提供的静态方法 macthes(regex , string); 实现正则表达式和字符串的匹配判断。

        注意：参数先是正则表达式，后是字符串。

3)        通过Pattern和 Matcher，其使用步骤：1-7

4)        步骤

u        1准备一个字符串

u        2根据单词的特点，组织一个正则表达式

u        3导入Pattern 和 Matcher 两个类。

u        4通过Pattern类的静态方法compile()将正则表达式编译成一个匹配模式对象。

u        5通过匹配模式对象的 matcher()方法将字符串转换成一个匹配器。

u        6查找

u        7获取

u        8显示

对话窗口的使用：JOptionPane.showMessageDialog和JOptionPane.showInputDialog

 

 

10/16

10/17

 

1什么是方法的重写？

        *          在子类中，对继承自父类的某个或某几个方法不满意（由于业务的需要），因此，对这个方法或这几个方法

        *   进行修改其方法体，而方法头部通常不变，所生成的新方法以便适合当前业务。这种现象称之为....（也称之为方法的覆盖）。

        *

        *          注意:从java5开始，在重写方法时，可以改变方法的返回值的类型。但，改变后的类型必须是原类型的子类。

        *

        *                 试想一下，当方法的返回值的类型为基本类型时，可以修改吗？ 答案：否定的。

        *                        即：只要返回值的类型为引用类型时，才可能修改。

        *

        *          注意:从java5开始 ，在重写方法时，还可以改变访问权限修饰符。但，权限不能越来越严格。（了解）

2

1、什么是多态？

        *          1)从生活的角度去理解多态。

        *

        *          2)从专业的角度去理解多态。

        *                 a)静态的多态。

        *

        *                 b)动态的多态。

        *

        *   2、通过一个案例理解并掌握多态。同时，找出使用多态的必要条件和好处？

        *

        *          结论:

        *                 多态实现的前提条件：

        *                        1)一定发生继承，有一个父类，多个子类。

        *                        2)在所有的子类中对来自父类的同一个方法重写(可重写多个)了。

        *                        3)父类的对象变量引用了多个子类的对象，从而形成了对象变量的多态。

        *                        4)在业务的解决中，通过父类的对象变量去调用重写的方法（动态绑定）。

        *

        *         

3.

结论: 多态的好处？

        *                 多态使得业务的解决具有统一性、系统性、高效性。

        *          1、什么是最终类？

        *                 用来 final 修饰 的类。

        *

        *          2、最终类有何特性？

        *                 最终类不可被继承的。例如:  String类

        *

        *          3、什么是最终方法？

        *                 用来final 修饰的方法。

        *

        *          4、最终方法有何特性？

        *                 防重写。       *

4、什么是抽象类？

        *                 1）从实际生活去理解？

        *

        *                 2）从专业讲：用 abstract 关键字修饰 的类。

        *

        *          2、什么是抽象方法？

        *                 当一个方法只知道做什么，不知道如何做。即：这种方法只有头部，没有方法体且被abstract关键字修饰着。

        *                 格式: ... abstract  .... 方法名(...) ;

        *

        *                 因此，若一个类中包含了一个或多个抽象方法，则这个类一定是抽象的。

        *

        *          3、抽象类的特性：

        *                 1)它一定被 abstract修饰。

        *  

        *                 2)它不能实例化。即：不能创建对象，也就不能通过对象去解决实际问题。

        *

        *                 3)抽象类必须 有子类，而且这个子类必须实现了来自抽象类的所有抽象方法。否则，这个子类也是抽象的。

        *

        *          注意： 抽象类一定包含了抽象方法，对吗？  答案： 不一定。

 

10/18

1          Object类：在Java语言中，存在一个超根类为 java.lang.Object类，它是所有类的祖先。

1.1         当我们在生成一个类时，若没有明确指其父类，则其父类默认为 Object类。

                           publicclass 类名  { ...... }

                           相当于

                           publicclass 类名  extends Object { ...... }

1.2         在Java语言中，一个有且仅有一个父类，但一个类可以有多个子类。

1.3         在Java语言中，一个父类的对象变量可以引用本类的对象，也可以引用孩子类的对象。然而，Object属性所有类的祖先。因此，Object类的对象变量可能引用本类的对象，也可以引用任何类的对象。

                           例如:  Object obj = new Object();

                                     obj = new Person();

                                     obj = new Student();

                                     obj = new Book();

                                     obj = new Dog();

                                                ......

         注意：

前提：父类的对象变量引用了孩子对象，父类的对象变量要去引用子类对象特有的方法时，则需要强制转换。

1.4         Object类提供的几个常用方法：

1.4.1    boolean  obj1.equals(obj2);  用来实现obj1和obj2两个对象比较相等。

祖先规定: 当obj1和obj2引用的是同一个对象时，则结果为true；反之，则结果为false。

       结论:在自定义类中，若要按自己的条件来判断对象相等，则需要重写 equals()方法。

1.4.2    String toString(); 用来以字符方式反馈对象的信息，它是默认调用的。

结论: 如果要通过对象变量直接打印其信息，则在自定义类中需要重写toString()方法。

2          接口（Interface）

2.1         什么是接口 ？ 如何理解接口？

              接口是一种标准、一种规范，更是一种统一的要求。

2.2         在java语言中，接口只包含什么？

             1) 抽象方法。

             2) 静态的常量。

         注意： 接口中的方法即使不写abstract修饰它，根据接口的特性它们也自然为抽象的。

2.3         在Java语言中，为什么要出现接口？

由于java语言中，一个类只有一个父类，即：只支持单继承，不支持多继承。然而，Java语言中，为了实现多继承，从而提供了接口。

              即: 一个类除了继承另一个类之外，还可以实现一个接口或多个接口。

      一个类实现接口格式如下：

             publicclass Student extends Person implements 接口1, 接口2, ...{  }

2.4         通过一个案例理解并掌握类为什么要实现接口，从而掌握接口的应用？

             案例：有许多学生，要求这些学生按入学成绩排序？

             分析：

²       要排序，就需要比较大小；要比较大小，就要指定条件。

²       然而，不论什么比较大小，其结果只有三种情况（大、小、等）;

²       为了规范比较，因此，比较大小的方法名称就可以统一要求；

²       比较的结果是否可以统一？可以，因为结果只有三种情况。

²       但是，比较的条件和过程不可统一，需要根据将来实际情况来定。

                          

        结论：这个方法一定是抽象的方法。

      

       假设：

              1)方法名统一为:  compareTo()

              2)结果为三种情况，因此，我用一个int型数据（>0 、 <0  和  ==0）可表示三种情况。

              3)比较需要两对象才能进行，因此，这个方法的形式参数为:  Object obj;

 

       组合为:   public abstract int compareTo(Object obj);

       同时，为了让这个方法被所有类实现（重写）它，则把置于接口中。

       因此，专家为所有程序员提供了一个  java.lang.Comparable接口，其中放了以上方法。用来实现对象的比较大小。

2.5         在Java语言中，接口有两种：

              根据业务的特性是否可以提前提出一种标准、一种规范和一种统一的要求来分：

1) 现存的接口 (即：提前提出来的标准、规范、统一的要求)

              2)自定义接口 (即：将来根据实际情况自已定义相关接口)

2.6         现存接口如何使用？

              1）导入（ import ）接口。

              2） 编写一个类去实现( implements )该接口。

              3） 在该实现类中对继承自接口的所有抽象方法要一一重写。

              4）编写测试类去测试它。

2.7         自定义接口如何生成，又如何使用？

              1） 通过关键字interface 来定义，格式为:  [public] interface 接口名 { ...... }

              2） 导入( import )该接口。

              3） 编写一个类实现( implements )该接口。

              4）在该实现类中 重写来自接口的所            1、什么是内部类？

        *                 被包含在一个类的类体中的类。

        *

        *          2、什么是外部类？

        *                 包含了内部类的类。

        *

        *          3、在内部类中的方法如何去访问外部类的成员（实例变量和方法）.

        *                 答案：直接访问。

        *

        *          4、在外部类的方法如何去访问内部类的成员（实例变量和方法）.

        *                 答案：不可直接访问，但如何访问？

        *                        通过内部类的对象去访问。

        *

        *          5、在外部类之外的类的方法如何访问内部类的成员？

        *                 假设有一个外部类A和一个内部类B，且add()是内部类的方法。则如何访问add()

        *

        *                 先创建A类的对象:   A aobj = new A();

        *                 再通过外部类的对象 aObj去创建一个内部类的对象:   A.B bobj = aobj.new  B(); 

        *                 最后通过内部类的对象去访问内部类的成员：  bobj.add();

        *

        *          6、什么是匿名的内部类？

        *                 没有名字的内部类(实际上不简单)。

        *有抽象方法。

              5） 编写一个测试类测试应用。

2.8         接口的特性：

             1) 接口中的方法一定是公共的、抽象的。因此 public abstract这两个修饰词可省略。

         2)接口中的常量一定是公共的、静态的、最终的。因此 public static final三个词可省略。

             3) 接口不可用来创建对象，但可以用接口的对象变量来引用其实现类的对象。

                    例如: Comparable  cObj = new Student();

4) 在生成一个接口时，接口可以没有父接口，也可以只有一个父接口，还可以有多个父接口。(这一点与类不同)

                    (案例说明)

3          内部类和外部类

3.1         什么是内部类？

答：被包含在一个类的类体中的类。

3.2         什么是外部类？

答：包含了内部类的类。

3.3         在内部类中的方法如何去访问外部类的成员（实例变量和方法）.

             答案：直接访问。

3.4         在外部类的方法如何去访问内部类的成员（实例变量和方法）.

             答案：不可直接访问，但如何访问？

                 通过内部类的对象去访问。

3.5         在外部类之外的类的方法如何访问内部类的成员？

             假设有一个外部类A和一个内部类B，且add()是内部类的方法。则如何访问add()

ü        先创建A类的对象:   A aobj = new A();

ü        再通过外部类的对象 aObj去创建一个内部类的对象:     A.B bobj = aobj.new  B(); 

ü        最后通过内部类的对象去访问内部类的成员：  bobj.add();

3.6         什么是匿名的内部类？

             没有名字的内部类(实际上不简单)。

 

3.7         通过案例观察并得出匿名的内部类如何生成，如何应用？

3.8         什么时候需要编写匿名的内部类？

答：在构建某个对象时，为了让某个类的方法更适合应用，需要重写这个方法，因此，在构建对象时，在构造器的末尾（即“；”后面），加上一对大括号，在里面写上方法体，所生成的一段代码叫做匿名类

如：static Arithmatic  obj = new Arithmatic(){ //匿名的内部类

              @Override

              public intadd(int x, int y) {

                     System.out.printf("%d+ %d = " , x, y );

                     return x +y;

              }

       };

使用情况：在特定的情况下使用特定的方法，则使用匿名的内部类来重写某个或某些方法。

 

4          回调

4.1         什么是回调？

答：一个特定事件发时所采取的动作。即：当某个事件产生，则驱动着某个方法来解决它；当这个事件反复产生时，则相应的方法要反复响应。

例如: 一个时间到达时，上课铃就响了。

       分析：发现回调往往是一种事件的自动驱动机制。既然要自动去响应，那么就需要监听机制。在java语言中，监听机制往往置于接口。因此，当某个对象需要拥有监听并响应处理功能，则需要去实现该接口。

4.2         通过一个案例进一步理解并掌握回调模式。

              案例：

                    设定一个时间，当这个时间到达时，就会自动在屏幕上打印一个问候信息。

                    分析: 需要一个定时器，还需要一个对象且该对象拥有监听和响应时间到达的功能。

        思考:

        1、通过键盘输入 exit 来控制程序的结束？

        2、通过设定一个时间来自动控制程序的结束？

        3、不打印问候信息，而在屏幕的同一行上显示一个时钟且一秒一秒地变化。

        4、设定一个次数来自动控制程序的结束？

 

10/21

1          Collection接口提供的常用方法：

Collection c1 =new HashSet() / LinkedList() / ArrayList() / TreeSet() ;

n        c1.add( new Integer(32) );  c1.add( 3.6 ); //添加元素

n        int n = c1.size(); //获取c1容器中元素的个数

n        c1.remove( b1 ); //从c1容器中删除b1元素。

n        c1.clear(); //清空

n        flag = c1.isEmpty();  //判断c1是否为空

判断容器之间的关系

n        c1.addAll( c2 ); //将c2中的所有元素复制一份添加到c1中

n        flag = c1.containsAll(c2); //判断c1中包含了c2的全部元素吗？

n        c1.removeAll(c2); //从c1中删除包含c2的所有元素。

n        c1.retainAll( c2 ); //从c1中删除不包含于c2的所有元素。 注意: 它与removeAll(c2)方法正好相反。

n        Object[] objs = c1.toArray();//将容器中的所有元素收集起来构成一个对象数组。

2          对与collection 接口相关的容器进行遍历

2.1         什么是遍历？

遍历：访问容器的所有元素，且每个元素只访问一次

2.2         如何对与Collection接口相关的容器进行遍历？

             有两种方式 :

1)     凡是与Collection接口相关的容器均拥有一个 iterator()方法，该方法用来反馈一个迭代器；

                    通过这个迭代器可实现容器的遍历。

                     迭代：访问所有元素时，下一个访问依据前一个元素进行的，这样就叫做迭代。

                   注意: 迭代器提供的方法:   hasNext();  next(); remove();

                     importjava.util.Iterator; //迭代器接口//1

Iterator  it =c1.iterator();  //2

             

                     while( it.hasNext() ){ //3 判断

                    

                            Object obj =it.next(); //4 访问(获取)

                            if( obj instanceof Byte || obj instanceof Short){

                            it.remove(); //通过迭代器将容器的指定元素删除。

                            }

                     System.out.println( obj ); //5 处理（显示）

                     }

2)     从 java5开始新增了一个for循环，可实现遍历。

Object[] objs = c1.toArray(); //将容器中的所有元素收集起来构成一个对象数组。

System.out.println("c1>>>" + c1 + " 分别如下：");

        for(Object  tem : objs ){

               System.out.println( tem );

        }

3          Collection接口的子接口Set

3.1         Set接口特性：

v        它的全部方法均来自父接口  Collection。

v        元素是无序的且不重复。 当添加重复的元素时，会采用屏蔽技术屏蔽掉。

v        它的常用实现类为:  HashSet。

v        它还有一个子接口为:  SortedSet。

       //功能: 主要是验证Set接口的特性（元素无序不重复）

3.2         Set接口的常用实现类为:  HashSet，其特性如下：

1)     它拥有父接口Set的所有方法。

2)     元素是无序的且不重复。当添加重复的元素时，会采用屏蔽技术屏蔽掉(即：重复的元素添加不进去)。

3)     HashSet实现类的个性是: 判断元素相等依赖equals()方法和hashCode()方法。

4)     为了验证第3)点，则容器中必须存放自己定义类的对象。

结论: 在HashSet相关的容器中存放的是自定义类的对象时，若要判断对象是否相等，不仅重写equals()方法，还要重写hashCode()方法。

3.3         补充: 什么是哈希编码？

a)    在Java语言中，规定：任何一个对象均拥有一个哈希编码，该编码就是一个int型整数且它由计算机自动分配。

b)    在Java语言中，还规定：相等的对象拥有相同的哈希编码。

c)    hashCode()方法来源于 Object类。Object类规定：只要是两个对象，其哈希编码值就不同。因此，若要让它们的哈希编码一样，则需要重写 hashCode()方法。

       重点：在HashSet实现类所构建的容器中判断元素相等依赖什么方法？

                     依赖 hashCode( ) 方法和  equals( ) 方法

4          Set接口的子接口为:  SortedSet，其特性如下：

4.1         元素自动按大小排序。

4.2         元素不重复。当添加重复的元素时，也会采用屏蔽技术屏蔽掉。

4.3         SortedSet接口的实现类为: TreeSet

4.3.1    元素会自动按大小排序。（在排序时会用到排序，即compareTo（）方法）

4.3.2    元素不重复，当添加重复元素时会采用屏蔽技术屏蔽掉。

4.3.3    判断元素相等依赖 equals()方法，但，实质它依赖 compareTo()方法。

注意： 在重写 compareTo()方法时，为了判断对象相等是根据所有属性是否相等来进行的。因此，在重写compareTo()方法体中要求对对象的所有属性一一比较大小。

       //目的: 验证当TreeSet类相关的容器中存放 的是自定义对象时，则要求什么？

结论: 当TreeSet类相关的容器中存放了自定义类的对象时，则要求该类必须实现 Comparable接口，重写  compareTo()方法为对象比较大小提供依据。

5          List接口

5.1         List接口有何特性？

5.1.1    它除了拥有父接口提供的方法外，它还增加了一些与位置相关的操作方法。插入、删除某位置上的元素、获取某位置上的元素、替换等。

案例主要验证： 它提供的与位置相关的操作方法。    

                     add( n , elem);

                     remove( n );

                     get( n );

                     set( n , newelem );

                    indexOf(elem);\

 

5.1.2    元素有序的（指元素会按位置存放）即：每个元素拥有一个位置索引号（从0开始）。

5.1.3    元素可以重复。因为，重复的元素可以在不同的位置上。

5.1.4    它的常用实现类：  LinkedList 和 ArrayList 。

5.1.4.1   LinkedList实现类 的特性？

1)      它拥有父接口的全部方法（如：插入、获取、删除，替换，查找等）。

2)       它的所有元素按位置存放，因此，元素可以重复；元素在位置上是有序的。

3)      它采用链表的原理的实现元素的管理 。因此，在插入和删除元素时效率较高，而查找元素时效率较低。

4)      判断 元素相等依赖  equals()方法。

5.1.4.2   是ArrayList实现类的 特性？

1)      它拥有父接口的全部方法（如：插入、获取、删除，替换，查找等）。

2)      它的所有元素按位置存放，因此，元素可以重复；元素在位置上是有序的。

3)      它采用队列的原理来管理元素。因此，元素在存储上是相邻的。但是，在插入和删除元素时效率较低，而在查找元素时效率较高。

4)      判断 元素相等依赖 equals() 方法。

5.1.5    对与List接口相关的容器进行遍历，除了前面讲过两种方法外，它自己还拥有ListIterator迭代器，通过它可实现遍历。

u   对与List接口相关的容器进行遍历，除了前面讲过两种方法外，它自己还拥有ListIterator迭代器，通过它可实现遍历。

u   该 ListIterator迭代器可以实现正遍历，也可实现逆向遍历

5.1.6    与List相关的容器存放自定义类的对象 且判断对象相等时，则它依赖 equals()方法。

      结论： 当与List接口相关的容器存放了自定义类的对象且要查找时，则该自定义类必须重写 equals()方法。

5.1.7    如何对 与List接口相关的容器中的所有元素进行排序？

                     在Java语言中，专家专门为 List接口编写一个工具类 java.util.Collections。

                    该类提供了几个常用的方法专门为List接口相关的容器进行处理（如: 排序）

 

思考: 当容器中存放了自定义类的对象时，则如何使用Collections工具类实现排序和查找？

Collections工具类是专门为 List接口相关容器进行操作提供方便高效的。

1)      掌握它提供的几个常用方法。

v        Collections.sort(alist );//排序

v        Collections.shuffle(alist );//打乱容器中元素的顺序

v        Collections.reverse(alist );//将alist逆序输出（头变尾，尾变头）

v        Collections.fill(alist, “ Hello” );//全部替换为“Hello”

v        Int x =Collections.binarysearch( alist, key );// 在alist容器中采用二分法查找key元素，前提是：所有元素必须先排序后查找。

2)      当List接口相关的容器中存放的是自定义类的对象时，则要求该类必须怎样？ 

      结论: 要求该自定义类必须实现Comparable接口，重写compareTo()方法，为对象比较大小提供依据。同时，要求在重写compareTo()方法时必须对对象的所有属性一一比较大小。

注意:

        List接口中有一个indexOf()方法也是用来查找的。该方法无须先排序，它是按顺序查找的。因此，它在查找时比较对象相等依赖 equals()方法。

      结论: 当List接口相关的容器中存放的是自定义类的对象时，则要求该类必须 重写 equals()方法。

10/22

6          Map接口的特性：

6.1         元素由键和值组成，其中键是唯一的。即：一个键对应着一个值。

6.2         所有的元素是无序的。 即：元素没有按键排序。

6.3         元素不重复，当添加相同的元素时，则采用覆盖技术，用新元素的值去覆盖旧元素的值。

(注意: 判断元素是否重复，只判断该元素的键是否在容器存在)

6.4         它为了规范容器的操作提供了几个常用的抽象方法：

ü        m1.put("水果1",3.5); //添加元素

ü        Object  obj = m1.get( "水果5"); //获取键为 水果5 的元素值。

ü        booleanflag = m1.containsKey("苹果"); //判断容器中有键 为 苹果 的元素吗

ü        flag =m1.containsValue( 1.5 ); //判断容器中有元素的值为 1.5 的元素吗？

ü        m1.remove("水果1" ); //从容器中删除元素的键为: 水果1 的元素。

ü        m1.clear(); //清空

ü        flag =m1.isEmpty();

ü        m1.putAll(m2); //将m2中的所有元素复制一份添加到m1中

ü        Set  keys = m1.keySet(); //1将m1容器中所有元素的键收集起来构成一个键组成的集合

6.5         它的常用实现类为 HashMap，*HashTable 。

6.5.1    Map接口的实现类 HashMap，其特性如下：

1)       它拥有Map接口的全部方法。

2)       它的元素是无序的。

3)       它的元素也是不重复，当添加重复的元素时会采用覆盖技术，用新元素的值覆盖旧元素的值。

4)       判断元素相等，只是判断元素的键是否相等。它依赖 equals()和hashCode()两个方法。

(   通过案例掌握 HashMap实现类的个性: 元素无序，不重复；判断元素相等依赖 equals()和hashCode()两个方法。

结论: 当HashMap实现类所构建的容器，且容器中存放的元素，其键为自定义类的对象时，则要求该 类必须重写 equals()和hashCode()两个方法，为对象判断相等提供依据。

6.6         Map接口的子接口为:  SortedMap，其特性如下：

1)       元素由键和值组成 ，键是唯一的。

2)       元素会按键的大小自动排序。

3)       元素不重复，当添加重复的元素时，会采用覆盖技术，用新元素的值覆盖旧元素的值。

4)        它的常用实现类:  TreeMap 。 

5)       TreeMap实现类的特性：

u        元素由键和值组成 ，键是唯一的。

u        元素会按键的大小自动排序。

u        元素不重复，当添加重复的元素时，会采用覆盖技术，用新元素的值覆盖旧元素的值。

u         它的个性： 当容器中元素的键为自定义类的对象时，则要该类怎样？

结论: 当容器的元素，其键为自定义类的对象时，则要求该类必须实现Comparable接口，重写compareTo()方法，为对象比较大小提供依据。

                     注意: 在重写compareTo()方法，要求对对象的所有属性一一比较大小。

 

1.Java数据类型基本数据类型与引用类型的区别？

  基本数据类型包括：整型、浮点型、字符型、布尔类型；

  引用数据类型包括：数组、类和接口
（1）对于基本数据类型，不同的变量会分配不同的存储空间，并且存储空间中存储的是该类的变量的值。赋值操作传递的是变量的值，改变一个变量的值不会影响另一个变量的值。
（2）对于引用数据类型，赋值是把原对象的引用（可以理解为内存地址）传递给另一个引用。对数组而言，当一个数组名直接给另一个数组名赋值时，相当于传递了一个引用，此时，两个引用指向同一个数组， 也就是指向同一个内存空间。

2.类似于成员变量可以分为实例变量和类变量，类方法也可以分为实例方法和类方法。
 （1）类变量，用static关键字修饰的变量。
 （2）类方法，用static关键字修饰的方法。
 （3）实例变量和实例方法，声明时不用static关键字修饰。
3.实例变量和类变量的区别
 （1）内存分配方面
     实例变量每个对象的实例变量都分配内存；类变量仅在生成第一个对象时分配内存。
 （2）在对象所属方面
    实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果。
4.实例方法和类方法的区别
 （1）在操作上
      实例方法可以对实例变量和类变量进行操作；类方法只能访问类变量，不能访问实例变量。
 （2）在使用方面
      类方法中不能使用this或super关键字，因为而静态方法与对象无关,this和super是属于对象范畴的东西，而静态方法根本不能把对象的引用传到方法中,所以不能用this或super关键字。

5.包的三大作用?

(1)区分相同名字的类。

(2)当类很多时，可以很好的管理类。

(3)控制访问范围。

6.多态的定义是：多态是通过只想父类的指针来调用在不同子类中实现方法。

7.方法重载的注意事项？

（1）方法名相同。

（2）方法参数类型、个数、顺序至少有一个相同。

（3）方法返回类型可以不同。

（4）方法的修饰符可以不同。

8.如果两个方法参数类型个数顺序都一样，只有返回类型不一样 这样可以吗？

答案不可以，理由见7.

9.Java的三大特征是 继承、封装、多态。

10.方法覆盖是指子类有个方法与父类的某个方法的名称返回类型相同。

 

1.对于不同语言运行环境下 byte 、int、short、等所占的字节是不相同。

2.java中数据类型可以自动的从低精度转至高精度。

3.当一个整数和一个double运算的时候结果向高精度转。

4.条件表达式switch数据类型和case后的常量一致，否则出错。

5.switch中可用数据类型主要是byte、short、int、char、enum.

 

转自：http://blog.csdn.net/u013163860/article/details/17338423