Java text:
类与对象：
类修饰符：
public
abstract
需要子类提供方法的实现，所以不能创建该类的实例
final
缺省：表示只有在相同包中的对象才能使用这样的类
一个类可以有多个修饰符，但abstract和final相互对立，所以不能同时应用在一个类的定义中
成员变量修饰符：
public
private
protected
缺省
final
static：指定该变量被所有对象共享，即所有的实例都可以使用该变量
transient
volatile：易失修饰符，指定该变量可以同时被几个线程控制和修改
成员变量和局部变量的区别：
成员变量是对象的一部分，而对象是存在于堆内存的，而局部变量是存在于栈内存的。
被final修饰但没有被static修饰的成员变量必须必须显示的赋值。局部变量不会自动赋值，必须手动显式赋值
new字符创建两个对象，两个对象的成员是分配在不同的地址块中，因此互不影响。
参数传递：
当参数是基本数据类型时，是传值方式调用
当参数是引用型的变量时，也是传值方式，只不过这个值其实是个地址值，所以也称为传址方式调用。
方法中的可变参数：
如果方法中有多个参数，可变参数必须位于最后一项
public static void display（int x,String...arg）{}
diaplay(1,"1","2","3");
匿名对象；
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象
将匿名对象作为实参传递给一个方法调用。
public static void getsomeone(MyClass c){}
getsomeone(new MyClass());
java语言类的特性：
缺省访问控制符:
类成员：
表示这个成员智能被同一个包中的类所访问和调用，如果一个子类与其父类位于不同的包中，子类也不能访问父类中的缺省访问控制成员，
也就是说其他包中的类都不能访问缺省访问控制成员。
类：
只能被同一个包中的类访问和调用。
方法重载：
参数个数不同
参数类型不同
参数的顺序不同
其他相同，返回值类型不同，不属于重载
构造方法：
一个构造方法的返回值类型就是类本身
构造方法调用另外一个构造方法：
public B（）｛
this．Ｂ（１２３） ／／this必须放在第一行
．．．
．．．．
．．．．．
｝
public B（int ｘ）｛｝
从一个构造方法中，调用另外一个构造方法必须使用ｔｈｉｓ来调用。
公共的构造方法和私有的构造方法：
私有的构造方法只能在类中被调用。
public A（int ｘ）｛
this．B（）； ／／this必须放在第一行
．．．
．．．．
｝
private A（）｛
｝
静态成员：
被static修饰的成员称为静态成员，也称为类成员（节省空间）
静态变量（类变量）：
静态变量是一个公共的存储单元，类的任何一个对象访问它的时候，取到的都是一个相同的数值。
类的任何一个对象修改它的时候，都是对同一个内存单元做操作。
静态变量独立于方法之外。
建议采用 类名．静态变量名 访问
静态方法（类方法）：
非static的方法是属于某个对象的方法，个对象间不相互影响
static方法是属于整个类的，static帆方法只能访问static成员变量或调用static方法。
静态方法中不能使用this和super
不被static修饰的成员称为实例成员。
变量：实例变量
方法：实例方法
静态初始化器：
static｛
．．．
．．．
．．．
｝
举例：
public static int i;
public static int m;
public static int n;
static {
i = 1;
m = 2;
n = 3;
}
特点：完成对整个类的初始化操作，包括给static成员变量赋初值，它在系统向内存加载时自动完成（只执行一次）
对象的应用：
对象的赋值和比较：
Test01 t2;
Test01 t1 = new Test01();
t2 = t1;
引用变量赋值后，这两个引用变量指向了同一个对象。任意一个引用变量对对象做修改，另一个引用变量所指向的对象内容也会随着更改。
所有引用变量都指向了同一个对象。
引用变量作为方法的返回值：
public class Test01 {
private String name;
private int age;
public Test01(String name,int age) {
this.name = name;
this.age = age;
}
public Test01 compare(Test01 t) {
if(this.age>t.age) {
return this;
}else {
return t;
}
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
Test01 t1 = new Test01("zhangsan",111);
Test01 t2 = new Test01("lisi",100);
Test01 t3;
t3 = t1.compare(t2);
System.out.println(t3.name);
System.out.println(t3.age);
}
}
类类型的数组：
public class Test01 {
private String name;
private int age;
public Test01(String name,int age) {
this.name = name;
this.age = age;
}
public Test01 compare(Test01 t) {
if(this.age>t.age) {
return this;
}else {
return t;
}
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
Test01[] t; ／／类类型的数组
t = new Test01[3];
t[0] = new Test01("zhangsan",12);
t[1] = new Test01("lisi",100);
t[2] = t[0].compare(t[1]);
System.out.println(t[2].name);
System.out.println(t[2].age);
}
}
Java语言的垃圾回收：
特点：
只有一个对象不被任何引用类型的变量使用的时候，它占用的内存才可能被垃圾回收器回收
不能通过程序强迫垃圾回收器立即执行
可以通过调用Sｙｓｔｅｍ．ｇｃ（）或者Rｕｎｔｉｍｅ．ｇｃ（）方法提示垃圾回收器进行内存回收操作。
但不能保证垃圾回收器立即执行。
当垃圾回收器将要释放无用对象占用的内存时，先调用对象的finalize（）方法。（系统回收时，自动调用finalize方法（））
继承，抽象类，接口和枚举：
类的继承：
一个父类可以同时拥有多个子类
Javａ语言中不支持多重继承，一个类只能有一个直接父类。
Java语言中有一个名为：Java．ｌａｎｇ．Ｏｂｊｅｃｔ的特殊类，所有的类都是直接或间接地继承该类而得到的。
子类的对象也是其父类的对象。反之不然，父类对象不一定是它的子类的对象。
在Java语言的继承中，执行子类的构造方法前，会先调用父类中没有参数的构造方法，其目的是为了要帮助继承自父类的成员做初始化操作。
在严格意义上来说，构造方法是不能被继承的，但是不意味子类调用父类的构造方法。
调用父类中特定的构造方法：
在子类的构造方法中通过ｓｕｐｅｒ（）语句来调用父类特定的构造方法。
如果父类中之定义了有参数的构造方法，而在子类的构造方法中又没有用ｓｕｐｅｒ（）来调用父类中特定的构造方法，则编译时会报错，
因为在父类中找不到“没有参数的构造方法”可供执行。解决方法是在父类中加上一个“不做事”且没有参数的构造方法既可，如public Test０２（）｛｝
ｓｕｐｅｒ（）和ｔｈｉｓ（）区别：
ｓｕｐｅｒ（）是从子类调用父类的构造方法，ｔｈｉｓ（）是在同一个类中调用其他的构造方法
ｓｕｐｅｒ（）和ｔｈｉｓ（）都要放在构造方法的第一行，所以在同一个构造方法中，ｓｕｐｅｒ（）和ｔｈｉｓ（）不能同时存在。
与ｔｈｉｓ一样，ｓｕｐｅｒ（）指的也是对象，所有ｓｕｐｅｒ（）同样不能在static环境中使用，包括静态方法和静态初始化器中。
覆盖：
子类中不能覆盖父类中声明为ｆｉｎａｌ和ｓｔａｔｉｃ的方法
在子类中覆盖父类的方法时，可以扩大父类中的方法权限，但不可以缩小父类方法的权限。不能更严格，例如父类中的protected可以改为public，但不能改为ｐｒｉｖａｔｅ
通过父类的对象访问子类的成员，只限于“覆盖”的情况发生时。也就是说，父类与子类的方法名称，参数个数和类型必须完全相同时，才可以通过父类的对象调用子类的方法。
向上转型：
将子类对象看作是父类对象，是从一个较具体的类到较抽象的类之间的转换。安全性高
向下转型：
将父类对象通过 强制转换 为子类型再赋值给子类对象的技术。是将较抽象的类转换为较具体的类。
ｆｉｎａｌ：
最终变量
最终方法
最终类
Oｂｊｅｃｔ类：
ｐｕｂｌｉｃ ｂｏｏｌｅａｎ ｅｑｕａｌｓ（Ｏｂｊｅｃｔ ｏｂｊ）
ｐｕｂｌｉｃ Ｓｔｒｉｎｇ ｔｏＳｔｒｉｎｇ （）
ｐｕｂｌｉｃ ｆｉｎａｌ Ｃｌａｓｓ ｇｅｔＣｌａｓｓ（）
Test01 t1 = new Test01("zhangsan",12);
Class obj = t1.getClass();
System.out.println(obj);
class day03.Test01
ｐｒｏｔｅｃｔｅｄ Ｏｂｊｅｃｔｃｌｏｎｅ（）
对象运算符：ｉｎｓｔａｎｃｅｏｆ ｐ１２８
抽象类：
抽象方法声明中修饰符static和abstract不能同时使用
abstract不能与ｐｒｉｖａｔｅ、ｓｔａｔｉｃ、ｆｉｎａｌ或ｎａｔｉｖｅ并列修饰同一个方法。
抽象类不一定包含抽象方法，但包含抽象方法的类一定是抽象类。
抽象类不能使用ｎｅｗ运算符创建具体实例对象，而必须通过覆盖的方式实现抽象类中的方法。
抽象类可以定义构造方法，但需要用protected来修饰，因为它只能被子类的构造方法所调用
public abstract class Shape {
protected String name;
abstract public double area();
abstract public double length();
public Shape(String name) {
this.name = name;
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class Circle extends Shape{
public int radius;
public Circle(String name,int radius) {
super(name);
this.radius = radius;
}
@Override
public double area() {
// TODO 自动生成的方法存根
return Math.PI*Math.pow(radius, 2);
}
@Override
public double length() {
// TODO 自动生成的方法存根
return 2*Math.PI*radius;
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
Shape circle = new Circle("circle",2);
System.out.println(circle.area());
System.out.println(circle.length());
}
}
接口：（主要功能是可以帮助实现类似与类的 多重继承 功能）：
抽象方法（默认：public abstract） 外，还可以定义 静态方法（默认：public static，不被继承） 和 默认方法（默认：public default），但不能定义一般方法。
ｉｎｔｅｒｆａｃｅ前面的public修饰符省略的话，则使用缺省的访问控制符，即只能被同一个包中的成员访问。
接口的数据成员都是 静态 的且 必须初始化 ，即数据成员必须是 静态常量 默认：public static
接口中除了声明 抽象方法（默认：public abstract） 外，还可以定义 静态方法（默认：public static，不被继承） 和 默认方法（默认：public default），但不能定义一般方法。 ／／ｎｏｔｅ：静态方法不能被类或接口所继承。
接口中的抽象方法只需做声明，不用定义其处理数据的方法体
接口中的成员都是公共的，所以在定义接口是若省略了public修饰符，在实现 抽象方法 时，则不能省略该修饰符
在实际定义接口时，一般都省略 数据成员与抽象方法 的修饰符。但，修饰静态方法的static和修饰默认方法的default不能省略 ｐ１３３
类实现接口时应注意的问题：
接口中抽象方法的访问控制符都已指定为public，所以类在实现方法时，必须显示地使用public修饰符，否则将被系统警告为缩小了接口中定义的方法的访问控制范围。
编译成功生成．ｃｌａｓｓ的字节码文件
接口的继承（一个接口可以继承多个接口）：
接口与接口之间的继承用的是ｅｘｔｅｎｄｓ，类继承接口用的是implement
与类的继承不同的是，一个接口可以有一个以上的父接口。新接口继承所有父接口中的常量，抽象方法和默认方法，但不能继承父接口中的静态方法，也不能被实现类所继承。
如果一个类实现的接口继承自另外一个接口，那么该类必须实现在接口继承链中定义的所有方法。
利用接口实现类的多重继承：
一个类可以实现多个接口》》》类似于类的多重继承
接口中的静态方法和默认方法：
接口中的静态方法不能被子接口继承，也不能被实现该接口的类继承。对接口中静态方法的访问，可以通过接口名直接进行访问，即＂接口名．静态方法名（）＂的形式进行访问。
public interface Face2 {
abstract double length();
static void show() {
System.out.println("this is face2");
}
}
Face2.show(); ／／接口名．静态方法名（）
接口中的默认方法可以被子接口或被实现该接口的类所继承，若子接口中定义名称相同的默认方法，则父接口中的默认方法被覆盖。在实现类中可以继承默认方法，也可以重写该默认方法。
访问接口的默认方法可以通过接口实现类的实例进行访问＂对象名．默认方法名（）＂
public interface Face2 {
abstract double length();
static void show() {
System.out.println("this is face2");
}
public default void Show() {
System.out.println("this is Show of face2");
}
}
cylinder.Show();
解决接口多重继承中名字冲突问题：（接口．ｓｕｐｅｒ．接口中的方法名）
public interface Face1 {
public default double area(int r) {
return Math.PI*Math.pow(r, 2);
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public interface Face2 {
public default double area(int r) {
return r*r;
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class Circle implements Face1,Face2{
public double area(int r) {
return Face1.super.area(r);
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
Circle circle = new Circle();
System.out.println(circle.area(2));
}
}
枚举enum：枚举是一种特殊的类，所以它是一种引用类型
需求：经常遇到有些数据的取值被限定在几个确定的值之间的情况，即这些值可以被一一列举出来。
声明为枚举类型，比较方便和安全。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
［修饰符］ ｅｎｕｍ 枚举类型名
｛
枚举成员１，枚举成员２，枚举成员３ ／／枚举常量，又称为枚举常量或枚举值
方法
｝
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
修饰符可以是public、private、internal
枚举类型名有两层含义：
一是作为枚举名使用
二是表示枚举成员的数据类型
注意：
枚举可以实现一个或多个接口，使用enum关键字声明的枚举默认继承了ｊａｖａ．ｌａｎｇ．Ｅｎｕｍ＜Ｅ＞类，而不是继承ｊａｖａ．ｌａｎｇ．Ｏｂｊｅｃｔ类。因此枚举不能显式的继承其他父类
使用ｅｎｕｍ定义 非抽象 的枚举类时默认使用 ｆｉｎａｌ 修饰，因此枚举类型 不能派生子类。
创建枚举类型的变量时 不能使用ｎｅｗ 字符，而是直接将 枚举成员 赋值给 枚举变量。
枚举是类，可以有自己的构造方法和其他方法，但构造方法必须用 ｐｒｉｖａｔｅ 修饰，默认private修饰符。只能使用ｐｒｉｖａｔｅ
枚举成员必须在 第一行 显式 列出，默认 public static final 进行修饰
可以使用运算符＝＝和！＝运算符比较两个枚举值是否相等。
枚举类型预定义的方法：Ｐ１４２
ｐｕｂｌｉｃ ｓｔａｔｉｃ ｅｎｕｍｔｙｐｅ［］ ｖａｌｕｅｓ（）／／返回枚举类型的数组，该数组包含枚举的所有枚举成员
ｐｕｂｌｉｃ ｓｔａｔｉｃ ｅｎｕｍｔｙｐｅ ｖａｌｕｅＯｆ（Ｓｔｒｉｎｇ ｓｔｒ） ／／返回名称为ｓｔｒ的枚举成员
枚举常量的访问方法：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public enum Test01 {
winter,summer,spring;
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class T_01 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Test01 t = Test01.spring; ／／使用枚举类型名．枚举成员名
Test01 t1 = Test01.valueOf("winter"); ／／使用枚举类型名．ｖａｌｕｅＯｆ（ｓｔｒ）
System.out.println(t);
System.out.println(t1);
for(Test01 t2:Test01.values()) { ／／遍历枚举中的枚举成员
System.out.println(t2.ordinal()+t2.name()); ／／t2.ordinal()枚举成员的序号，t2.name（）枚举成员的名称
}
}
}
包含属性和方法的枚举：
枚举的构造方法只在构造枚举成员的使用被调用，每一个枚举成员都是枚举的一个对象，因此创建每个枚举成员都需要调用该构造方法
－－－－－－－－－－－－－－－－－－－－－－－－－－
public enum Direction {
south("南"),north("北");
private String name;
private Direction(String name) { //构造方法，必须使用private，默认private
this.name = name;
}
public String toString() {
return name;
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class T_02 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Direction d = Enum.valueOf(Direction.class,"north");
System.out.println(d);
for(Direction d1:Direction.values()) {
System.out.println(d1.ordinal()+d1.name()+d1.toString());
}
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－
北
0south南
1north北
－－－－－－－－－－－－－－－－－－－－－－－－－－－
注意！！！！！！
每一个枚举成员都是枚举的一个对象，因此创建每个枚举成员都需要调用该构造方法
注意！！！！
－－－－－－－－－－－－－－－－－－－－－－－－－－
Direction d2 = Direction.valueOf("south");
System.out.println(d2.name()); ／／．ｎａｍｅ返回的是枚举成员名
System.out.println(d2); ／／返回枚举的属性值
－－－－－－－－－－－－－－－－－－－－－－－－－－
south
南
－－－－－－－－－－－－－－－－－－－－－－－－－－
包：
使用package语句创建包：
package ｃｇｊ．ｌｙ．ｍｙｐａｃｋａｇｅ
注意：包名应和文件夹名的大小写一致
无名包
使用包名时，如果要改变一个包名，就必须同时改变对应的文件夹名
Java语言中的常用包：ｐ１４５
Java．ｌａｎｇ：语言包
自动加载的
Java语言中常用的几个类：
Dａｔｅ类
Ｃａｌｅｎｄａｒ类
Rａｎｄｏｍ类
利用ｉｍｐｏｒｔ语句导入Java定义的包：
Java程序结构：
ｐａｃｋａｇｅ声明包，０或 １个
ｉｍｐｏｒｔ 导入包，０或 多个
ｐｕｂｌｉｃ ｃｌａｓｓ 声明公有类，０个或１个，文件名和类名相同
ｃｌａｓｓ 声明类 ０或 多个
ｉｎｔｅｒｆａｃｅ 声明接口 ０或多个
注意！！！！！！ 声明为public的类最多一个，且文件名和类名相同
异常处理：ｐ１５９
如将子类异常的ｃａｔｃｈ语句块放在父类异常ｃａｔｃｈ块后面，则编译不能通过
当ｃａｔｃｈ块中含有Sｙｓｔｅｍ．ｅｘｉｔ（０）语句时，则不执行ｆｉｎａｌｌｙ块中的语句，程序直接退出
当ｃａｔｃｈ块中含有return语句时，则执行完ｆｉｎａｌｌｙ块中的语句后再终止程序。
ｊａｖａ语言的输入输出与文件处理
流：
输入流
只能从其读取数据，不能向其写入数据
输出流
只能向其写入数据，不能从其读取数据
字节流
IｎｐｕｔＳｔｒｅａｍ和OｕｔｐｕｔＳｔｒｅａｍ
字节流所操作的基本数据单元是８位字节，无论是输入输出都是直接对字节进行处理
字符流
Rｅａｄｅｒ和Wｒｉｔｅ
字符流操作的基本数据单元是１６位字符（ｕｎｉｃｏｎｄｅ），无论是输入输出都是直接对字符进行处理
Java 流(Stream)、文件(File)和IO
读取控制台输入：
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
public class A {
public static void main(String[] args) throws IOException{ ／／必须抛出声明IOException
// TODO 自动生成的方法存根
char c;
BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
do {
c = (char)bf.read(); ／／读取字符
}while(c!='q');
String str;
do {
str = (String)bf.readLine(); ／／读取字符串
}while(!str.equals("end"));
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
控制台输出：
void write(int byteval)
－－－－－－－－－－－－－－－－－－
int c = 'A';
System.out.write(c);
System.out.write('\n');
－－－－－－－－－－－－－－－－－－
write() 方法不经常使用，因为 print() 和 println() 方法用起来更为方便。
读写文件：
FileInputStream
InputStream f = new FileInputStream("C:/java/hello");
未完待续！！！
文件输入输出流：
FileInputStream && FileOutputStream:
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
package day16;
import java.io.*;
import java.util.*;
public class TestFileStream {
public static void main(String[] args) {
// TODO 自动生成的方法存根
FileOutputStream fos = null;
FileInputStream fis = null;
String string = " abcdefg";
try{
fos = new FileOutputStream("D:\\eclipse\\temp_proj001\\testFile001.txt",true);
fos.write(string.getBytes());
fos.flush();
}catch(FileNotFoundException e) {
e.printStackTrace();
}catch(IOException e){
e.printStackTrace();
}finally {
if(fos!=null) {
try{
fos.close();
}catch(IOException e) {
e.printStackTrace();
}
}
}
StringBuffer sb = new StringBuffer();
int length = 0;
int n = 0;
try {
fis = new FileInputStream("D:\\eclipse\\temp_proj001\\testFile001.txt");
byte[] bt;
while((length=fis.available())>0) {
bt = new byte[fis.available()];
n = fis.read(bt);
sb.append(new String(bt,0,length));
System.out.println(sb.toString());
}
}catch(IOException e) {
e.printStackTrace();
}finally {
if(fis!=null) {
try{
fis.close();
}catch(IOException e) {
e.printStackTrace();
}
}
}
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
DataOutputStream && DataInputStream:
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
package day16;
import java.util.*;
import java.io.*;
public class TestDataStream {
public static void main(String[] args) {
// TODO 自动生成的方法存根
DataOutputStream dos = null;
DataInputStream dis = null;
try {
dos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream("D:\\eclipse\\temp_proj001\\TestDataStream_01.txt")));
dis = new DataInputStream(new BufferedInputStream(new FileInputStream("D:\\eclipse\\temp_proj001\\TestDataStream_01.txt")));
dos.write(10);
dos.writeBoolean(false);
dos.writeDouble(0.01232321);
dos.flush();
System.out.println(dis.read());
System.out.println(dis.readBoolean());
System.out.println(dis.readDouble());
}catch(IOException e) {
e.printStackTrace();
}finally {
if(dos!=null) {
try {
dos.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
if(dis!=null) {
try {
dis.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
FileWriter && FileReader:
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
package day16;
import java.io.*;
public class TestReaderWriter {
public static void main(String[] args) {
// TODO 自动生成的方法存根
String s1 = new String("D:\\eclipse\\temp_proj001\\a.txt");
String s2 = new String("D:\\eclipse\\temp_proj001\\b.txt");
copyFile(s1,s2);
}
public static void copyFile(String s1,String s2) {
FileWriter fw = null;
FileReader fr = null;
int c;
try {
fw = new FileWriter(s1);
fr = new FileReader(s2);
while((c = fr.read())!=-1) {
fw.write(c);
}
fw.flush();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
if(fw!=null) {
try {
fw.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
if(fr!=null) {
try {
fr.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
BufferedReader && BufferedWriter:
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
package day16;
import java.io.*;
public class TestReaderWriter01 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
copyBufferedFile();
}
public static void copyBufferedFile() {
FileWriter fw = null;
FileReader fr = null;
BufferedReader br = null;
BufferedWriter bw = null;
String string = "";
try {
fw = new FileWriter("D:\\eclipse\\temp_proj001\\a.txt");
fr = new FileReader("D:\\eclipse\\temp_proj001\\b.txt");
br = new BufferedReader(fr);
bw = new BufferedWriter(fw);
while((string = br.readLine())!=null) {
bw.write(string);
}
bw.flush();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
if(bw!=null) {
try {
bw.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
if(br!=null) {
try {
br.close();
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}
}
}
}
}
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
泛型：
1、------------------------------------------------------------------------------------------------
package day12;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest01 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
// List myList = new ArrayList();
// Cat c = new Cat();
// Bird b = new Bird();
// myList.add(c);
// myList.add(b);
// Iterator it = myList.iterator();
// while(it.hasNext()) {
// Object obj = it.next();
// if(obj instanceof Bird) {
// Bird bird = (Bird) obj;
// bird.fly();
// }
// if(obj instanceof Cat) {
// Cat cat = (Cat) obj;
// cat.catMouse();
// }
// if(obj instanceof Animal) {
// Animal animal = (Animal) obj;
// animal.move();
// }
//
// }
List<Animal> myList = new ArrayList<Animal>();
Cat c = new Cat();
Bird b = new Bird();
myList.add(c);
myList.add(b);
Iterator<Animal> it = myList.iterator();
while(it.hasNext()) {
Animal a = it.next();
a.move();
if(a instanceof Cat) {
Cat cat = (Cat) a;
cat.catMouse();
}
if(a instanceof Bird) {
Bird bird = (Bird) a;
bird.fly();
}
}
}
}
class Animal{
public void move() {
System.out.println("动物在移动");
}
}
class Cat extends Animal{
public void catMouse() {
System.out.println("猫抓老鼠");
}
}
class Bird extends Animal{
public void fly() {
System.out.println("鸟儿在飞翔");
}
}
------------------------------------------------------------------------------------------------
动物在移动
猫抓老鼠
动物在移动
鸟儿在飞翔
2、------------------------------------------------------------------------------------------------
package day12;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class GenericTest02 {
/*
* jdk之后推出了：自动类型推断机制（又称为砖石表达式）
*/
public static void main(String[] args) {
// TODO 自动生成的方法存根
/*
* ArrayList<>这里的类型自动推动，jdk8之后
*/
List<Animal> myList = new ArrayList<>();
myList.add(new Animal());
myList.add(new Cat());
myList.add(new Bird());
Iterator<Animal> it = myList.iterator();
while(it.hasNext()) {
Animal a = it.next();
a.move();
}
}
}
------------------------------------------------------------------------------------------------
动物在移动
动物在移动
动物在移动
3、------------------------------------------------------------------------------------------------
package day12;
/*
* 自定义泛型
*/
public class GenericTest03<T>{
public void doSome(T o) {
System.out.println(o);
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
GenericTest03<String> gt = new GenericTest03<>();
gt.doSome("abc");
GenericTest03<Integer> gt1 = new GenericTest03<>();
gt1.doSome(100);
MyIterator<String> mt = new MyIterator<String>();
mt.get();
//不用泛型是object类型
GenericTest03 gt2 = new GenericTest03();
gt2.doSome(new Animal());
}
}
class MyIterator<T>{
public T get() {
return null;
}
}
------------------------------------------------------------------------------------------------
abc
100
day12.Animal@6a5fc7f7
Collection类：
1、 --------------------------------------------------------------------------------------
package day10;
import java.util.ArrayList;
import java.util.Collection;
import java.util.LinkedList;
/*还没学泛型之前，collection中可以存只要是object的子类就行，但是不能存基本数据类型，也甭能存
Java对象，只是存储java对象的内存地址，
*/
public class CollectionTest01 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Collection c = new ArrayList();
Collection b = new LinkedList();
c.add(1200); //自动装箱
c.add(1200);
c.add(1200);
c.add(1200);
c.add(1200);
System.out.println(c.size());
c.clear();
System.out.println(c.size());
c.add("1"); //自动装箱
c.add("2");
c.add("3");
c.add("hello");
c.add(new Student());
System.out.println(c.size());
Object[] obj = c.toArray();
for(Object i:c) {
System.out.println(i);
}
}
}
class Student{
public String toString() {
return getClass().getName()+"";
}
}
--------------------------------------------------------------------------------------
5
0
5
1
2
3
hello
day10.Student
2、 --------------------------------------------------------------------------------------
package day10;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class CollectionTest02 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
//以下讲解的遍历方式是所有collection通用的一种方式。在map集合中了不能用，在所有的collection以及子类中使用
//创建集合对象
Collection c = new HashSet();
Collection b = new HashSet();
c.add(1);
c.add(2);
c.add(3);
c.add(4);
c.add(5);
c.add(6);
c.add(7);
b.add(16);
b.add(13);
b.add(12);
b.add(55);
b.add(34);
c.add(new Student1());
c.addAll(b);
Iterator it = c.iterator();
/*
*boolean hasNext()
*Object next()
*
*/
while(it.hasNext()) {
Object i = it.next();
System.out.println(i);
}
}
}
class Student1{
public String toString() {
return getClass().getName()+"";
}
}
--------------------------------------------------------------------------------------
1
day10.Student1
2
34
3
4
5
6
7
12
13
16
55
3、 --------------------------------------------------------------------------------------
package day10;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest03 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Collection c = new ArrayList();
c.add(1);
c.add(2);
c.add(3);
c.add(3);
c.add(new Object());
Iterator it = c.iterator();
while(it.hasNext()) {
Object obj = it.next();
if (obj instanceof Integer) {
System.out.println("Integer");
}
System.out.println(obj);
}
}
}
--------------------------------------------------------------------------------------
Integer
1
Integer
2
Integer
3
Integer
3
java.lang.Object@3ac3fd8b
4、 --------------------------------------------------------------------------------------
package day10;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest04 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Collection c = new ArrayList();
User s1 = new User("jack");
c.add(s1);
User s2 = new User("jack");
System.out.println(c.contains(s2));
Integer x = new Integer(1000);
Integer y = new Integer(1000);
c.add(x);
System.out.println(c.contains(y));
}
}
class User{
private String name;
public User() {
}
public User(String name) {
this.name = name;
}
public boolean equals(Object c) {
//放在集合中的元素，要重写equals方法
if(c==null || !(c instanceof User)) return false;
if(c==this) return true;
User u = (User)c;
return this.name.equals(u.name);
}
}
--------------------------------------------------------------------------------------
true
true
5、 --------------------------------------------------------------------------------------
package day10;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest05 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Collection c = new ArrayList();
String s1 = new String("hello");
c.add(s1);
String s2 = new String("hello");
System.out.println(c.size());
c.remove(s2);
System.out.println(c.size());
}
}
--------------------------------------------------------------------------------------
1
0
6、 --------------------------------------------------------------------------------------
package day10;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionTest06 {
public static void main(String[] args) {
// TODO 自动生成的方法存根
Collection c = new ArrayList();
c.add(1);
c.add(2);
c.add(3);
c.add(4);
Iterator it = c.iterator();
while(it.hasNext()) {
Object i = it.next();
it.remove();
System.out.println(i+" "+c.size());
}
}
}
--------------------------------------------------------------------------------------
1
0
序列化与反序列化：
将对象及数据从内存中放到硬盘上
反序列化：
------------------------------------------------------------------------------------------------
package day14;
import java.io.*;
import java.util.*;
public class ObjectOutputStreamTest02 {
public static void main(String[] args) throws FileNotFoundException, IOException {
// TODO 自动生成的方法存根
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\eclipse\\temp_proj001\\users"));
List<User> userlist = new ArrayList<>();
userlist.add(new User(1,"zhangsan"));
userlist.add(new User(2,"lisi"));
userlist.add(new User(3,"wangwu"));
oos.writeObject(userlist);
oos.flush();
}
}
class User implements Serializable{
private int num;
private transient String name; //transient 表示不参与序列化
public User(int num,String name) {
this.num = num;
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getNum() {
return num;
}
public void setNum(int num) {
this.num = num;
}
public String toString() {
return getClass().getName()+":"+"{"+this.num+","+this.name+"}";
}
}
------------------------------------------------------------------------------------------------
反序列化：
------------------------------------------------------------------------------------------------
package day14;
import java.io.*;
import java.util.*;
public class ObjectInputStreamTest02 {
public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
// TODO 自动生成的方法存根
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\eclipse\\temp_proj001\\users"));
Object obj = ois.readObject();
// System.out.println(obj instanceof List);
List<User> userlist = (List<User>) obj;
for(User user:userlist) {
System.out.println(user);
}
ois.close();
}
}
------------------------------------------------------------------------------------------------
day14.User:{1,null}
day14.User:{2,null}
day14.User:{3,null}
序列化版本号：后期改代码不会影响。
public static final long serialVersionUID=2323213232323L;
private int age;
线程：
多线程的主要目的：就是将一个程序中的各个程序段＂并行化＂
Character:
Character.isLetter('a');
Character.isDigit('5');
Character.isWhiteSpace(' ');
Character.isUpperCase('c');
Character.toUpperCase('c');
Character.toString('a');
Math:
Math.PI
Math.sin()
Math.cos()
Math.tan()
Math.atan()
Math.toDegress()
Math.toRadians()
Math.abs(a)
Math.ceil(a)
Math.floor(a)
Math.rint(a)
Math.round()
Math.exp()
Math.log()
Math.pow(x,y)
Math.sqrt()
Math.asin()
Math.acos()
Math.atan()
Math.random()
Integer:
x.byteValue()
x.doubleValue()
x.longValue()
x.intValue()
x.shortValue()
x.compareTo(x1)
x.equals(x1)
Integer x = Integer.valueOf(9);
Double x = Double.valueOf(9);
int x = Double.parseInt("9");
Integer．MAX_VALUE;
String:
Str.toUpperCase()
String strOrig = "Google Runoob Taobao";
int intIndex = strOrig.indexOf("Runoob");
String string="runoob";
String reverse = new StringBuffer(string).reverse().toString();
String str="Hello World";
System.out.println( str.replace( 'H','W' ) );
System.out.println( str.replaceFirst("He", "Wa") );
System.out.println( str.replaceAll("He", "Ha") );
public static String removeCharAt(String s, int pos)
{ return s.substring(0, pos) + s.substring(pos + 1); }
Arrays:
Arrays.asList(str)
Arrays.getInt(index)
Arrays.binarySearch(str,char)
Arrays.sort(array)
Arrays.toString(obj)
Arrays.fill(array,start_index,end_index,fill_num);
Arrays.fill(array, 100);
Arrays.fill(array,0,3,0);
Arrays.equals(ary, ary2)
Collection:
Collection.min()
Collection.max()
System:
System.arraycopy(str1, start, str2, start, length);
boolean match1 = first_str. regionMatches(11, second_str, 12, 9);
StringTokenizer st2 = new StringTokenizer(str, ",");
while (st2.hasMoreElements()) {
System.out.println(st2.nextElement());
}
throw:
throw new RuntimeException("元素越界... ");
ArrayList:
ArrayList<String> al = new ArrayList<String>();
al.add(0, "a");
al.remove(0);
al.remove("a");
al.get(1);
al.set(1, "e");//修改存在的值
al.size();//查看长度、大小
ArrayList<Integer> li=new Arraylist<>(); // 存放整数元素
ArrayList<Character> li=new Arraylist<>(); // 存放字符元素
方法 描述
add() 将元素插入到指定位置的 arraylist 中
addAll() 添加集合中的所有元素到 arraylist 中
clear() 删除 arraylist 中的所有元素
nums.clear();
clone() 复制一份 arraylist
contains() 判断元素是否在 arraylist
get() 通过索引值获取 arraylist 中的元素
indexOf() 返回 arraylist 中元素的索引值
removeAll() 删除存在于指定集合中的 arraylist 里的所有元素
remove() 删除 arraylist 里的单个元素
size() 返回 arraylist 里元素数量
isEmpty() 判断 arraylist 是否为空
subList() 截取部分 arraylist 的元素
set() 替换 arraylist 中指定索引的元素
sort() 对 arraylist 元素进行排序
toArray() 将 arraylist 转换为数组
toString() 将 arraylist 转换为字符串
ensureCapacity() 设置指定容量大小的 arraylist
lastIndexOf() 返回指定元素在 arraylist 中最后一次出现的位置
retainAll() 保留 arraylist 中在指定集合中也存在的那些元素
containsAll() 查看 arraylist 是否包含指定集合中的所有元素
trimToSize() 将 arraylist 中的容量调整为数组中的元素个数
removeRange() 删除 arraylist 中指定索引之间存在的元素
replaceAll() 将给定的操作内容替换掉数组中每一个元素
removeIf() 删除所有满足特定条件的 arraylist 元素
forEach() 遍历 arraylist 中每一个元素并执行特定操作
求差集：
objArray.removeAll(objArray2);
求交集：
objArray.retainAll(objArray2);
求并集：
HashSet<String> hs = new HashSet<String>();
hs.add("a");
hs.add("a");
类与继承：
方法的重写规则
参数列表与被重写方法的参数列表必须完全相同。
返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
父类的成员方法只能被它的子类重写。
声明为 final 的方法不能被重写。
声明为 static 的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个类，则不能重写该类的方法。
多态：
多态的优点
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性
多态存在的三个必要条件
继承
重写
父类引用指向子类对象：Parent p = new Child();
478
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
