java se第一阶段学习总结

大家好，欢迎来到IT知识分享网。

jingcha123#%##%

数组：
1.数组特性：
1）数组属于引用类型；因此，一个数组就是一个对象
2）数据拥有一个length属性，表示数组的元素个数或数组长度。
3） 数组具有相同的名称，规定存放相同类型的数据；
4）数组的每一个元素拥有一个索引号，它从0 至 length – 1 。
5） 数组一旦创建，其元素个数不变。

3.在java中，数组必须先声明，再创建，初始化，最后使用。
前提：一维数组：
数组声明的格式：类型名[] 数组名；或者 类型名 数组名[];
例如： int[] a; int a[];
　　
　　数组的创建：格式：　　　a = new int[n]; f1 = new float[22];

数组的初始化：for（int i = 0； i < a.length; i++）{
a[i] = 值；
}
注意：在声明数组时，不能指定其元素个数 例如：int[5] a; //error

4.为了提高一维数组的处理效率，专家提供了工具类：Arrays
1）它来源于 java.util.Arrays;
2）主要用来处理任意类型的一维数组；
3)常用方法：
String toString（数组名）； //将给定的数组的所有元素组成一个字符串。并输出
void sort(数组名）； // 排序，由小到大排序， 不输出
int binarySearch（a,key） ; //在数组a 中按二分查找方式去查找key元素；
//若存在，则反馈其位置编号；反之，反馈一个负数；
使用方式： Arrays.sort(a), a 是数组 ； Arrays.binarySearch(a,key); Arrays.toString(a);
注意：查找前，要先对数组的所有元素有小到大排列。之后，再来采用二分查找方式查找元素。

优点： 二分查找的优点：速度快，

boolean equals(数组名1，数组名2)；//比较两个数组是否完全相等。
// 类型相同，长度一样，对应位置上的元素相等。

静态导入和非静态导入的区别：
例如： 静态导入：
public class Tools {
//方法: 输出int型数组的元素值
public static void printArray( int[] x ){
for( int tem : x ){
System.out.print( tem + ” “);
}
}
}
注意： 静态导入：使用静态导入可以使被导入类的静态变量和静态方法在当前类直接可见 ； 使用时直接使用 “静态方法”
格式：　import static 包名.类名.静态成员变量; 或者 import static 包名.类名.*;

非静态导入：
格式： import 包名.类名;
使用时： 类创建一个对象，使用对象调用类的方法或属性。

数组：
1）一维数组：带有一个索引号的一组数据。
2）多维数组：数组的元素拥有两个或两个以上的索引号，这样的数组称为多维数组。

注意：在java中，实质上没有多维数组，多维数组实质上是多个一维数组的组合。
注意：多维数组创建的时候，先从高维开始，到低维。

类： ————————————ArrayTest4.java
数组的赋值：
1）假复制： 将一个数组的名称赋给另一个数组名，则为假复制； 这种现象，在方法中传递参数时常用。
例如： int[] a = {1,2,4,11,5}; int[] b = a; // 其实这两个数组指向同一个数组的内存地址。

2）真复制： 将一个数组中的所有元素或部分元素复制到另一个数组中存放。
例如：int[] a = {1,2,4,11,5};
int[] c = new int[a.length];
System.arraycopy(a, 2, c, 1, 3); a: a数组； 2：代表从a数组下标2开始。 c ；数组。 1：从数组c 下标 1 开始。 3： 代表数组c长度

2.真复制数组需要使用：System系统类的arraycopy（）方法来实现。例如；System.arraycopy(a, 2, c, 1, 3);
3.java.util.Arrays; 还提供了 Arrays.equals(a, c); //判断2个数组是否完全相等。即：在长度，元素类型，对于位置上元素一样，要完全相同。

4.java中还自带的克隆方法，其单独的克隆了一份a数组的内容，当然地址也不一样了。
int[] d = a.clone();
if (d == a) {
System.out.println(“地址相同”);
}else{
System.out.println(“地址不相同”); √
}

常识：
1.字符+数字——》字符 例如： char[] s = new int[2]; s[1] = (char)(‘a’+1); s[1] = ‘b’;
2.字符转成数字： 例如： char B = ‘b’; int A = B;
3.取出26个字母中随机的一个字母，
String str = “abcdefghijklmnopqrstuvwxyz”; char ss = str.charAt((int)(26 * Math.random()));
4. Math.random():随机的0—1之间的数。 Math.pow(x,y): x 的 y 平方 。Math.round(x) :x 的四舍五入法。 Math.sqrt(x): x 的 平方根

======================================================

1.命令行：向计算机发出命令所在的行。
2.在java中，命令行的参数有谁来接受： 它由main方法的形式参数String[] args来接受，且接受后，将所有参数统统变为字符串类型。
例如：

3.命令行的参数如何给定：
在eclipse环境下，给参数：。。。
在命令窗口下给参数：
例如：
if( args.length == 0 ){
System.out.println(“命令行没有给实际参数，我无法继续为你工作。”);
System.out.println(“byebye!”);
System.exit(0);
}
System.out.println(“\n说明，此时，命令行有参数。它们分别如下：”);
for(int i = 0; i < args.length; i++ ){
System.out.println(“args[” + i + “]=” + args[i] );
}

注意：不论在哪种环境下给参数，都需要注意，参数与参数之间用空格隔开。而然，当参数本身包含空格时，则这个参数必须用一对双引号将它括起来。例如：“i love java!”

对象的克隆：生成一个新对象。但是，对于多维数组来讲，则不是。

注意：针对一维数组，克隆时，则生成一个新数组 。若针对多维数组进行克隆，则并不是生成了一个独立的多维数组。
例如：int[][] a = {{1,2},{2,3}}; int [][] b = a.clone();

=================================================异常
异常是什么：
1. 定义：在Java语言中，程序在运行期间会出现这样和那样的问题，这种问题称之为异常。
2.java中采用“类”去模拟异常。。类是可以创建对象的。对象的可以显示异常。
异常的本质：程序发生了异常，JVM为我们创建了对应的异常类型的对象（ArithmeticException类型的对象）并且对这个对象中包含了详细的异常信息，并且JVM将这个对象中的信息输出到控制台。

注意：在java中，凡是可通过程序能解决的问题成为异常，反之，称之为错误。

2.在java中，为什么需要提供异常及其处理方案： 为了减轻程序员的负担，为了提高程序的健壮性。
3.在java中，异常由来自java.lang.Exception类来管理。
4.异常的分类：
1）已检查出的异常：编译报错，且错误信息为 “Unhandleed Exception type XXXX”;也称之为已检查的异常。
2）未检查出的异常：编译时通过，运行时产生异常。

注意：已检查的异常必须使用异常处理机制来处理；

5.在java中，为了确保程序不会因为这样和那样的问题（异常）而出现瘫痪的现象。
为此，提供了异常处理机制。=========》java语言的健壮性

6.java的异常处理机制：
1）在方法的头部使用throws 关键字将异常抛出（抛弃）；
2）在方法体中 try{ 业务代码 } catch（ 异常类 异常变量 ）{ 异常处理信息 } 一个语句块来处理掉异常；即：在 try 中遇到异常，则跳转到 catch
3）建议：a.首先需要从语法上，逻辑上多查看代码，是否存在问题。
b.再从业务上查看逻辑是否不全面。
c.最后，真的找不到什么问题时，则需要多测试，之后根据业务来确定是否采用异常处理。

7.一个try后面可以跟上一个或多个catch。
注：每个业务单独使用try{}catch{} 来实现异常的处理，这种现象称之为小粒度的异常处理。
注：try里面的如果出现错误代码，则try里后面的代码不再执行，直接跳到catch
注：多个catch，其顺序是：先处理子异常，后处理父异常。

8.异常对象的三个的方法：
String toString(); 用来获取异常的名称 和 异常的原因。 System.out.println(e.getMessage());
getMessage(); 获取异常的原因。 System.out.println(e.toString());
void printStackTrace(); 用来打印异常的全部信息（ 异常的名称， 异常的原因， 异常的发生位置 ） 直接： e.printStackTrace();
注意：这三个方法通常便于程序员查找代码中的异常现象。

9.finally语句块应用：
它必须与try配合使用，它管理的语句块一定会执行。 即：try的代码不论是否有异常，finally语句块一定会执行。
finally：语句块通常用来干什么： 答： 用来关闭打开的文件或端口连接的数据库。

10.什么时候使用throws关键字：
：在编写方法是，方法体中若有异常，且不想处理掉，则往往在方法头部通过throws关键字将产生的异常抛出去。
格式：throws 异常类名

11.一个try后面可以跟上一个 catch或多个catch； 同时，后面还可跟上一个 finally语句块。
也可以: 一个try后面只跟上一个 finally语句块 （ 表示某个业务一定要执行，则此业务通常置于 finally语句块中 ）。

1.自定义异常类：
1）一般情况下，异常的管理往往使用专家提供的异常类。
2）当程序员自己发现某种问题，需要使用一个准确的信息来描述它并处理它，这种情况下往往自定义一个异常类来实现。

其步骤如下：
1) 给这个类找个父类。
2) 在这个类中编写两个构造器即可。
a) 默认构造器;
b) 带 String message 参数的构造器，且在该构造器中使用 super( message ); 语句来设置异常的原因。

2.在java中。throw关键字的使用：
1）它用来在方法中抛出（产生的）异常
2）格式：throw new 异常类的构造器
同时：往往需要在方法头部合用 throws 关键字配合它，实现异常往往抛出（抛弃）？？？？
注意：throw关键字是指将方法中的某种问题当成异常来看待。

子类重写父类的方法：（包括继承父类的异常）

1、在重写方法时，如何对待原方法抛出的异常？

1) 在重写方法时，可以抛出原异常或原异常的子异常，但，不能抛出比原异常更高级的异常。

2) 在重写方法时，不可抛出比原方法更多的异常（但, 有时不指个数）
a) 当多出来的异常属于未检查出的异常时，则合法。
b) 当多出来的异常属于原异常出的子异常时，则也合法。
c) 当多出来的异常属于已检查出的异常，且不是原异常的子类， 则非法。 // 即：异常是平行的。

5) 积累认识一些常见的异常类。
NullPointerException —> 对象不存在时，产生此异常
ArrayIndexOutOfBoundsException —> 越界异常 , 即: 索引号超出了界线。
ArithmaticException —> 算术异常
IOException —-> 输入输出异常
FileNotFoundException —-> 文件 找不到的异常
ParseException —-> 解析异常
Exception —-> 可处理的异常的父类。

==========================================java常用类
1.基本类型的封装类：
1）在java中？？？
因此，java为基本类型的数据提供了相应的封装类。

基本类型的关键字 ： 类
byte ======>>>Byte
short======>Short
int =======> Integer …
long ======> Long
float ======>Float
double ======>Double
char ======>Character ….
boolean =====> Boolean

注意： 提供封装类的目的，就是需要将基本数据转换为对象，从而让它拥有一些属性和方法；通过其方法可以解决一些问题。

2）从java5开始，新增了一个特性： （装箱：就是将。。。转换成对象）
自动装箱和自动自动拆箱。

3）将数值型字符串还原为数值本身。例如“24” ==>24 ； 纯数字的字符串。
Integer.parseInt(String); Float.parseFloat(String); Double.parseDouble(String);

4）？？？

2.java.lang.String 类 注意：它管理的字符串是不变的。

另外，在java中，还有一种可变得字符串；由？？？

3.可变字符串：
由StringBuffer和StringBuilder两个类来管理。
其中 前者效率低，但，它线程安全。后者，效率高，线程不安全。

从理解角度看：？？？

各种可变串的使用：？？？

1.日期与时间的管理类：Date类
1）它来源于java.util.Date;
2) 它用来？？？
3） 在java中，基准日期与时间为？？？

4）Date类的常用构造器
1.默认构造器，他所构造的对象，其对应的日期时间与系统时钟是一致的。
2.来long time 参数的构造器，其构造的对象，对应的日期是与参数相关的。

5）Date类？？？

6）日期时间的格式化
1.System.out.printf(“信息<格式控制符>“，日期时间对象）；
日期时间的格式控制符，它以 “%t”方式出现。
如： %tF :当前日期 %tT ：当前时间 %tA ： 星期
注：%1$d : $ 表示输出的索引，

2.String.format(“信息<格式控制符>“，日期时间对象）；

2.DateFormat类：
1）它来源于java.text.*包。
2）它是一个抽象类，
3）它的作用：
a)用来实现日期时间的格式化 ？？//有一个类专门负责格式化时间
String pattern = “yyyy年MM月dd日 hh:mm:ss”;
DateFormat dateFormat = new SimpleDateFormat(pattern);

b)用来实现日期时间型？？？

3.SimpleDateFormat 类：
1)它来源于java.text.*包。？？
2）它是一个普通类，它也是DateFormat 类的子类。？？
3）？？？？？

注意：？？？ 还有它的父类是抽象类，那它有没有继承抽象性（即能不能创建对象）

1.Calendar

2.在java中，日历由java.util.Calendar;抽象类和 其子类？？？
1）说明：在日历中？？？？

3.日历中常用的构造器：
1）默认的构造器：GregorianCalenddar();用它所构造的对象，会将日历自动定位到与当时的时间匹配的时间
GregorianCalendar calendar = new GregorianCalendar();
//星期的第一天是星期一
calendar.set(Calendar.YEAR, 2006);
calendar.set(Calendar.MONTH, 11);
//获取一个日历对应的属性的值
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH));
System.out.println(calendar.get(Calendar.DATE));
System.out.println(calendar.get(Calendar.HOUR));

4.常用方法：？？

各种包的导入？？？
（还有继承的那个方法的修饰符，不能等级更高吗？？？）

equalsTo :?????? 还是不会啊

常识：非静态方法中可以直接调用静态方法，静态方法中不可以调用非静态方法。
int 》》short, char ,类型的，类型的变化
string类会自动调用，具体的怎样呢？？？

异常的处理方式
1. throws: 抛出
1）.使用throws处理异常不是真正处理异常而是推卸责任。
2）.谁调用那个异常的方法，就会抛给谁。
例如：m1()方法在主函数中调用，如果m1()方法出现异常，如果采取上抛throws给了JVM，JVM遇到这个异常就会推出JVM，m1()下面的代码就不会执行。

2.try…catch..
1）catch语句块可以写多个，
2）但是从上到下catch，必须从小类型异常到大类型异常进行捕捉，如果大的类型异常在前面，则后面的小类型异常就可以不用写了。
3）try…catch.. 中最多执行1个catch语句块。执行结束之后try…catch…就结束了。
4）try中代码出现了异常，则try语句块后面的代码就不在继续执行，直接进入catch语句块中执行。
try{
可能出现的异常的代码；
}catch（异常类型1 变量）{
处理异常的代码；
}catch（异常类型2 变量）{
处理异常的代码；
}…

例如： try{
FileInputStream fiss = new FileInputStream(“c:/abdc.txt”);
fiss.read();
}catch (FileNotFoundException e){ //文件未找到异常捕捉
System.out.println(e.getMessage);
}catch (IOException ed){ //输入输出流异常捕捉
System.out.println(ed.getMessage);
}

关于getMessage 和 printStackTrace方法的应用
1.getMessage ：取得异常描述信息
2.printStackTrace: 取得异常的堆栈信息（比较适合于程序调试阶段）：printStackTrace();

作业：ArrayTest5.

接口的实现。
数组那章需要手动练习。？？

为什么一个类中只有一个 public ？？
do while , while（） ， switch case , if else , 等等。。
continue，break，。
接口和抽象类的网上练习，多练练，很重要。。。
1.现存接口，
2.自定义接口。。
3.接口的成份： 公共的静态的常量， 公共的抽象的方法。
4.匿名的内部类。

那个不重复的取出一些数字。1~10之间取出9个不重复的数字。？？？？？重要 ，循环。
常识：classPath，告诉JVM到哪去找.class文件 ,;%JAVA_HOME%\lib
path：告诉操作系统到哪去找可执行文件。%JAVA_HOME%\bin

path,classPath, homePath,,,?????
import java.util.Arrays; 的使用，忘记了，。。。尤其 toString

这周学习思路，
/**
1、OOP之前有问题？ ===>>> if while for switch
pass

2、OOP：
封装性:
1) 类的框架: 五个部分=====>>> Person —>
2) 类的应用: 构造对象, 调用方法解决问题 =====>> PersonTest

3) this 关键字
this()或this(参数列表);
this作用为对象( this.XXX 或 this.方法 或 return this; )

4) 方法的重载和构造器重载

5) 静态变量（类变量）和 静态方法

6) 静态初始化块(在类第一次加载时执行且只执行一次)

继承性:
1) Person =====>> Student ====>> StudentTest

2) super关键字 ( super()或super(参数列表) 和 super.方法 )

3) 方法重写 ( super.方法 )

多态性:
1) Shape —> Circle/ Rectangle / Triangle —-> ShapesTest —> ShapesTestNew

//多态
Shape s1 = new Circle();

2) 动态绑定:
s1.area(); //子类重写后的方法

3) 通过父类的对象变量去访问子类的特有成员（方法或属性）
则需要向下转型.

超根类: Object
toString()
equals()

接口:
现存接口;

自定义接口;

public class 实现类 [ implements 接口1, 接口2, … ] { ……. }

public interface 子接口 [ extends 父接口1, 父接口2, ] { ….. }

注意: 接口中的成份最多有两种: 公共的静态的常量； 公共的抽象的方法。

匿名的内部类>

3、最常用的类:
String类 —->>
“ABC”，这样的串具有共享性, 字符串不变。
字符串的常用方法 length() charAt() substring() indexOf lastIndexOf() replace()
equals() …. toLowerCase() toUpperCase() trim() …

Math类:
random() round() sqrt() pow()

*/

今天因为我向老师提了一个生活问题，老师最后记住了，还夸我了。其实我是什么样的，我是知道的，每天在后面浏览网页，玩手机。。。。
以后要注意：脑子又不好使，还不努力。你想死啊！