面向对象的思想
anything is Object（万物皆对象）
抽象，从对具体的对象中抽取有用信息。
对象有其固有属性，对象的方法，即对象的行为（对象能做什么）
对象本身是简单的（功能简单），多个对象可以组成复杂的系统（对象之间彼此调用对方的
方法）
对象应当是各司其职（功能简单），各尽所能（把自己的功能作到最好）。（弱耦合性实现
了前面所述的对象的特点）
对象的耦合性，是对象之间的联系，对象和系统之间的联系。对象的耦合性要尽量的弱，也
就是对象之间的联系尽可能的弱，对象和系统之间的联系尽可能的弱。
系统的可插入性，是在系统中加入新的对象之后的系统稳定性。
对象的可替换性，是在系统中替换原有的对象之后的系统的稳定性。
复用性，即对象可否被重复使用，对象的功能越简单，复用性就越好。（对象的耦合性弱，
复用性就比较强）
面向过程是先有算法，后又数据结构（怎么解决问题）
面向对象是先有对象（数据结构），后有算法。（用什么做）
类是某些有着相同属性的集合的抽象。
类是一个类对象的模板，对象是类的具体化。
类是一个新的数据类型，类的对象。
注意：局部变量的作用范围是在定义他的代码块以内，局部变量要先赋值后使用，在以一个重合的作用于范围内不允许两个局部变量命名冲突。局部变量局部优先，且在于实例变量同名时会副该局部变量。
变量 包括简单变量（原始数据类型），对象变量。
方法的定义：
1，方法的修饰符（多个修饰符出现的顺序无关） |
2，方法的返回值类型 |顺
3，方法名 |序
4，方法的参数表 |向
5，方法中允许抛出的异常 |下
V
java中不能够在返回语句后写任何代码。JVM+解释器=JRE，JRE+类库=JDK
java中方法的重载（overload）方法名相同，参数表不同，返回值类型可以不同。调用时要给出明确参数并确定调用某一方法。在编译时，编译器会根据参数选择适当的方法，所以重载也叫编译时多态。
就近向上匹配原则
如果方法的参数表中的数据类型和调用时给出的参数类型不尽相同时会根据向上匹配的就近原则。（类型就近向上转化匹配）
注意：调用时要给出明确参数并确定调用某一方法，否则编译会出错。
对象使用者（调用其他对象的方法）对象（对象中的方法被调用时根据参数进行自己进行选择）
一类方法，但跟据不同的参数会有差异，对象回根据参数判断，对对象调用者透明。
创建对象的过程，1，分配空间 2，初始化属性 3，调用构造方法（有前提，不考虑继承关系）
构造方法的写法，没有返回值类型，构造方法的方法命名必须和类名相同。如果在类中不写构造方法，系统会提供一个无参的构造方法。
注意：最好在写类时提供一个无参的构造方法。
获得对象的方式
通过new（在堆空间中申请分配空间），new 类名（），可以通过这种形式获得一个对象，这时的对象是无法使
用，必须把的他的地址存放近一个对象变量才能够使用。例如 ：Car c=new Car();
有参的构造方法在被调用时，在用new关键字获得对象时初始化，例如：Car c=new Car("yellow")
对象变量中存放的是对象的引用（地址的封装形式）
this关键字，表示当前对象（哪个对象调用了方法，哪个对象就是当前对象），可以用来区分实例变量和局部变量。this(),他表示掉用本类其他的构造方法，注，只能写在构造方法的第一行。
java中的参数传递，简单类型的变量传递的是数值，对象变量的传递则传递的一个引用（地址）
面向对象的三大特征：封装、继承、多态。
封装，一个对象和外界的联系应当通过一个统一的接口，应当公开的公开，应当隐藏的隐藏。（对象的属性应当隐藏），一个对象的内部是透明的，就是把对象内部的可透明性和隐藏的特性区分开，该透明的透明，该隐藏的隐藏。
（封装的属性）java中类的属性的访问权限的默认值不是private，要想隐藏该属性或方法，就可以加private（私有）修饰符，来限制只能够在类的内部进行访问。
对于类中的私有属性，要对其给出一对方法（getXxx(),setXxx()）访问私有属性，保证对私有属性的操作的安
全性。
方法的封装，对于方法的封装，该公开的公开，该隐藏的隐藏。方法公开的是方法的声明（定义），即（只须知道参数和返回值就可以调用该方法），隐藏方法的实现会使实现的改变对架构的影响最小化。。
封装会使方法实现的改变对架构的影响最小化。
完全的封装，类的属性全部私有化，并且提供一对函数来访问属性。
==================
day 04
=============
访问控制符
public 全部可见
protected 本类可见，同包可见，子类可见
default 本类可见，同包可见
private 本类可见
继承：父类的成员能否继承到子类，子类能否访问到父类的成员
父类的非私有化属性(不同包的子类无法访问default修饰符)和方法可以默认继承到子类。
Class Son extends Father{
}
而如果父类中的私有方法被子类调用的话，则编译报错。
父类的构造方法子类不可以继承，更不存在覆盖的问题。
所以子类构造方法默认调用父类的无参构造方法。（所以养成写无参构造的习惯）
如果子类访问父类的有参构造方法，必须在子类构造方法第一行使用super(参数)
当构造一个对象的时候，系统先构造父类对象，再构造子类对象。
Public class BMWcar extends Car{
Public BMWcar(){
Super(int alength); //显式的调用父类的构造，默认调用无参构造
//所以父类没有无参构造的话，子类如果不加显示调用其他构造就会报错
。这里的super是一个对父类的引用
}
}
private：本类内部可以访问 不能继承到子类
（default）：本类内部可以访问，同包其他类也可以访问能否继承到子类不一定,父子类同包可以访问
protected：本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问能继承到子类
public：任何地方都可以访问能继承到子类
从严到宽
覆盖：
方法名：相同
参数表：相同
访问限制符：相同或者更宽
返回值类型：相同 或者 子类返回的类型是父类返回的类型的子类
对象的构造过程：
1.递归的构造父类对象
2.分配空间
3.初始化属性
4.调用本类的某一个构造方法
super：调用父类的某一个构造方法super(),在构造方法中如果没有this()和super()的话会隐含的有一行语句即super(),调用父类的无参构造方法。
父类对象super，在有权限访问的前提下可以放文父类中的内容。
多态：
1. 对象不变
2. 只能对对象调用编译时类型中定义的方法
3. 运行时，根据对象的运行时类型，找覆盖过的方法来调用（运行时动态类型判定）
强制类型转换 instanceof
多态的意义屏蔽子类的个性差异差异，利用父类共性做出通用编程
属性的遮盖（shadow）没有多态，方法的重载看参数的编译时类型
多态分两种：
1编译时多态：编译时动态重载；
2运行时多态：指一个对象可以具有多个类型，方法的覆盖
这样对于对象而言分为：
理解运行时多态：
Car c = new Bus();
Car编译时类型 编译时检查变量类型是否存在，是否有调用的方法
Bus运行时类型 实际运行是访问heep中的对象，调用实际的方法。
运行时多态是由运行时类型决定的
编译时多态是由编译时类型决定的
猫，小鸟，狗 都是动物，都可以安上动物的标签。
Interface Animal{}
Class Car implements Animal{}
Class Bird implements Animal{}
Class Dog implements Animal{}
方法中
Animal a = new Car();
Animal b = new Bird();
Animal c = new Dog();
*方法重载看的是参数的编译时类型
public class Animal{
public static void main(String[] args){
}
}
(1) 是覆盖吗？不能多态了
abstract class MyClass{
priavate void m();
}
class Sub extends MyClass(){
public void m();
}
(2) 错误的修饰符组合
abstract class MyClass{
priavate abstract void m();
}
class Sub extends MyClass(){
public void m();
}
(3) 5.0 新 非覆盖
abstract class MyClass{
private final void m();
}
class Sub extends MyClass(){
public void m();
}
运行时多态的三原则
1.对象不变；（改变的是主观认识）
2.对于对象的调用只能限于编译时类型的方法，如调用运行时类型方法报错。
在上面的例子中：Animal a=new Dog()；对象a的编译时类型为Animal，运行时类型为dog。
注意：编译时类型一定要为运行时类型的父类或者同类型。
对于语句：Dog d=(Dog)a。将d强制声明为a类型，此时d为Dog()，此时d就可以调用运行时类型。注意：a和d指向同一对象。
3.动态类型判定实际调用的方法。即它调用覆盖后的方法。
关系运算符：instanceof
instanceof Animal;(这个式子的结果是一个布尔表达式)
上面语句是判定a是否可以贴Animal标签。如果可以贴则返回true，否则返回false。
在上面的题目中： a instanceof Animal返回 True，
a instanceof Dog也返回 True，
用于判定前面的对象是否是后边的类或者子类。
Animal a = new Car();
If(a instanceof Dog){
Dog b =(Dog)a;
}
else if(a instanceof Car){
Car c =(Car)a
}
不会错。
＝＝＝＝＝＝＝
day 05
===========
java中的修饰符
static 表示静态，它可以修饰属性，方法和代码块。
1，static修饰属性（类变量），那么这个属性就可以用 类名.属性名 来访问，也就是使这个属性成为本类的类变量，为
本类对象所共有。这个属性就是全类公有。（共有的类变量与对象无关，只和类有关）。
类加载的过程，类本身也是保存在文件中（字节码文件保存着类的信息）的，java会通过I/O流把类的文件（字节码文件）读入JVM（java虚拟机），这个过程成为类的加载。JVM（java虚拟机）会通过类路径（CLASSPATH）来找字节码文件。
类变量，会在加载时自动初始化，初始化规则和实例变量相同。
注意：类中的实例变量是在创建对象时被初始化的，被static修饰的属性，也就是类变量，是在类加载时被创建并进行初
始化，类加载的过程是进行一次。也就是类变量只会被创建一次。
2，static修饰方法（静态方法），会使这个方法成为整个类所公有的方法，可以用类名.方法名 访问。
注意：static修饰的方法，不直接能访问本类中的非静态(static)成员（包括方法和属性），本类的非静态（static）方
法可以访问本类的静态成员（包括方法和属性），可以调用静态方法。静态方法要慎重使用。在静态方法中不能出现this
关键字。
注意：父类中是静态方法，子类中不能覆盖为非静态方法，在符合覆盖规则的前提下，在父子类中，父类中的静态方法可
以被子类中的静态方法覆盖，但是没有多态。（在使用对象调用静态方法是其实是调用编译时类型的静态方法）
注意：父子类中，静态方法只能被静态方法覆盖，父子类中，非静态方法只能被非静态方法覆盖。
java中的main方法必须写成static的因为，在类加载时无法创建对象，因为静态方法可以不通过对象调用
所以在类的main方法。所在在类加载时就可以通过main方法入口来运行程序。
3，static修饰初始代码块，这时这个初始代码块就叫做静态初始代码块，这个代码块只在类加载时被执行一次。可以用静态初始代码块初始化一个类。
动态初始代码块，写在类体中的“{}”，这个代码块是在生成对象的初始化属性是运行。这种代码块叫动态初始代码块。
类在什么时候会被加载，创建对象时会加载类，调用类中静态方法或访问静态属性也是会加载类的。在加载子类时必会先
加载父类，类加载会有延迟加载原则，只有在必须加载时才会加载。
final修饰符，可以修饰变量，方法，类
1,final修饰变量
被fianl修饰的变量就会变成常量（常量应当大写），一旦赋值不能改变，（可以在初始化时直接赋值，也可以在构造方法里也可以赋值，只能在这两种方法里二选一，不能不为常量赋值），fianl的常量不会有默认初始值，对于直接在初始化是赋值时final修饰符常和static修饰符一起使用。
2，final修饰方法，被final修饰的方法将不能被其子类覆盖，保持方法的稳定不能被覆盖。
3，final修饰类，被final修饰的类将不能被继承。final类中的方法也都是final的。
注意：final，不能用来修饰构造方法，在父类中如果有常量属性，在子类中使用常量属性时是不会进行父类的类加载。
不变模式，对象一旦创建属性就不会改变。用final修饰属性，也用final修饰类（强不变模式），用final修饰属性（弱不变模式）。
不变模式的典型体现：java.lang.String类，不变模式可以实现对象的共享（可以用一个对象实例赋值给多个对象变量。
）
池化的思想，把需要共享的数据放在池中（节省空间，共享数据）
只有String类可以用“”中的字面值创建对象。在String类中，以字面值创建时，会到Java方法空间的串池空间中去查找
，如果有就返回串池中字符串的地址，并把这个地址付给对象变量。如果没有则会在串池里创建一个字符串对象，并返回
其地址付购对象变量，当另一个以字面值创建对象时则会重复上述过程。
如果是new在堆空间中创建String类的对象，则不会有上述的过程。
String类中的intern()方法会将在堆空间中创建的String类对象中的字符串和串池中的比对，如果有相同的串就返回这个
串的串池中的地址。
不变模式在对于对象进行修改，添加操作是使相当麻烦的，他会产生很多的中间垃圾对象。创建和销毁的资源的开销是相
当大的。
String类在字符串连接时会先的效率很低，就是因为它所产生的对象的书性是不能够修改的，当连接字符串时也就是只能
创建新的对象。
对于很多的字符串连接，应当使用StringBuffer类，在使用这个类的对象来进行字符串连接时就不会有多余的中间对象生
成，从而优化了效率。
abstract（抽象）修饰符，可以修饰类和方法
1，abstract修饰类，会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型，抽象类就像当于一类的半成品，需要子类继承并覆盖其中的抽象方法。
2，abstract修饰方法，会使这个方法变成抽象方法，也就是只有声明（定义）而没有实现，实现部分以";"代替。需要子
类继承实现（覆盖）。
注意：有抽象方法的类一定是抽象类。但是抽象类中不一定都是抽象方法，也可以全是具体方法。
abstract修饰符在修饰类时必须放在类名前。
abstract修饰方法就是要求其子类覆盖（实现）这个方法。调用时可以以多态方式调用子类覆盖（实现）后的方法，也就
是说抽象方法必须在其子类中实现，除非子类本身也是抽象类。
注意：父类是抽象类，其中有抽象方法，那么子类继承父类，并把父类中的所有抽象方法都实现（覆盖）了，子类才有创
建对象的实例的能力，否则子类也必须是抽象类。抽象类中可以有构造方法，是子类在构造子类对象时需要调用的父类（
抽象类）的构造方法。
final和abstract，private和abstract，static和abstract，这些是不能放在一起的修饰符，因为abstract修饰的方法是
必须在其子类中实现（覆盖），才能以多态方式调用，以上修饰符在修饰方法时期子类都覆盖不了这个方法，final是不可以覆盖，private是不能够继承到子类，所以也就不能覆盖，static是可以覆盖的，但是在调用时会调用编译时类型的方法，因为调用的是父类的方法，而父类的方法又是抽象的方法，又不能够调用，所以上的修饰符不能放在一起。
抽象（abstract）方法代表了某种标准，定义标准，定义功能，在子类中去实现功能（子类继承了父类并需要给出从父类
继承的抽象方法的实现）。
方法一时间想不到怎么被实现，或有意要子类去实现而定义某种标准，这个方法可以被定义为抽象。(abstract)
模板方法模式
用abstract把制订标准和实现标准分开，制定的标准就是模板，实现就是按模板标准来实现，也就是继承模板，实现模板
中相应功能的方法。模板中不允许修改的方法可以用fianl来修饰，这个方法不能使抽象方法，为保证安全，封装，把模板中不公开的部分用protected（保护）修饰。
＝＝＝＝＝＝＝＝＝＝＝
day 06
=================
java中的接口
接口是一种程序结构，是特殊的抽象类。接口中的方法必须都是公开的抽象方法（public abstract），接口中的属性都是公开静态常量（public static final）。
声明一个接口用 interface 关键字,接口也是一种类型，编译之后也有生成相应字节码，他的声明规范也要符合类型的定义(一个源文件中只能有一个public interface，接口名和源文件名相同，有public interface，就不能在写public class了)。接口中的属性可以不加修饰符，方法也不用加修饰符。
接口也可以继承，但是只能由接口继承，在用类去继承时要换用 implements 关键字，这时类和接口也不叫做继承关系，而是实现关系，但其实质也是继承。
一个类可以继承也只能继承另外一个类，但是可以实现多个接口，其语法是在implements后面写接口名，多个接口以“，”分隔。
接口之间是可以多继承的，其语法和类的继承语法是相同的，在接口多继承时，在extends后写接口名如果要继承多个接口，接口名以“，”分隔，接口的继承关系只是把其父接口中的抽象方法继承到子接口中。要实现接口就必须实现接口中的所有方法。
一个类可以在继承一个类的同时，也可以实现一个或多个接口。采用接口就绕开了单继承限制。
接口类型也可以做为编译时类型使用，但其实际的运行时类型必须是完全实现接口的类的对象实例，这样就使多态变得很灵活了，
注意：实现接口时，在实现(覆盖)抽象方法时，注意必须要在方法的返回值类型前加public修饰符。如果没有完全实现接口中的方法，那么这个类就只能够是个抽象类，不能创建对象。接口的是实质就是特殊的抽象类。接口没有构造方法。
接口的意义：
1，接口可以实现多继承。
2，用接口可以实现混合类型（主类型，副类型），java中可以通过接口分出主次类型。主类型使用继承，副类型，使用接口实现。
3，接口进一步深化了标准的思想，接口本身就是一个标准，他起到了降低耦合性的作用，接口可以使方法的定义和实现相分离，也就是将接口的定义者和实现者相分离，接口也可以用于降低模块间或系统间的耦合性。针对接口编程可以屏蔽不同实现间的差异，看到的只是实现好的功能，
接口：定义标准，
接口的实现：实现标准
接口的使用：标准的使用
针对接口编程原则，也就是按照标准实现。
先有接口的定义，再有接口使用者，最后把接口的是先对象川入接口的使用者中，接口的使用者会通过接口来调用接口实现者的方法。
接口的定义者定义好了标准，接口的使用者先写好了使用代码，接口的实现者写好实现之后把实现对象传入接口的使用者中。他会回调接口中的方法。这种过程叫做接口的回调。
尽量使用接口类型作为编译时类型，尽量将抽取到的共性行为写在接口中。
用若干个小接口取代一个大接口。（接口隔离原则）
把一个类的功能作成接口，只暴露想暴露的方法，接口隔离原则可以实现更高层次的封装，针对的对象不同，暴露的方法也不同。
java中的根类Object
java中所有的类的父类或直接或间接的或隐含的都是Object类。
java不允许循环继承，也就是互相继承是不可以的。
Object类中的finalize()一个对象被垃圾收集的时候，
Object类中有一个String toString()方法，返回该对象的字符串表示。Object类中的toString()方法他返回的是类名加上他的地址的一个字符串。在子类中推荐覆盖toString()方法。
Object类中的boolean equals(Object o)方法是用来比较对象的内容是否相等，其返回值是boolean类型的值，相同为真，不同则为假。实际上还是比较对象地址是否相同。String类覆盖了equals()方法，他比较是对象中的内容是否相同。子类中也推荐覆盖Object类中继承的equals()方法
equals()的覆盖原则，
自反性 x.equals(x) 为true
对称性 y.equals(x) 和 x.equals(y) 的值要相同，要么都为true，要么都为false。
传递性 x.equals(y)为true， y.equals(z)也为true ，那么x.equals(z)一定也为true。
覆盖equals()方法的步骤
boolean equals(Object o){
if(this==o) return true;//1,看看是不是一个对象
if(o==null) return true;//2,看看对象是不是空
if(!(o instanceof 本类类名)) return false；//看看是不是本类对象
......//根据本类设计。
}
代码：
--------------------------------------------------------------------------------
=============
1. 接口作为副类型
public class TestEmployee{
public static void main(String[] args){
Employee[] es=new Employee[4];
es[0]=new SalariedEmployee("Liucy",8,5000);
es[1]=new HourlyEmployee("Chenzq",2,40,200);
es[2]=new SalesEmployee("DuBin",8,0.03,80000);
es[3]=new BasePlusSalesEmployee("Winnie",10,0.08,150000,8000);
for(int i=0;i<es.length;i++){
System.out.println(es[i].getName()+": "+es[i].getSalary(
8));
}
//判断对象是否是Plusable对象，可以加班的对象
//强制转成Plusable，计算加班费
double d=0;
for(int i=0;i<es.length;i++){
if (es[i] instanceof Plusable){
Plusable p=(Plusable)es[i];
d+=p.getPlusSalary();
}
}
System.out.println(d);
}
}
class Employee{
private String name;
private int month;
public Employee(String name, int month) {
this.name = name;
this.month = month;
}
public String getName() {
return name;
}
//一般员工的共性部分，判断生日
public double getSalary(int month){
if(this.month==month) return 100;
else return 0;
}
}
interface Plusable{
double getPlusSalary();
}
class SalariedEmployee extends Employee implements Plusable{
private double salary;
//构造参数设置父类属性
public SalariedEmployee(String name, int month,double salary) {
super(name, month);
this.salary=salary;
}
public double getSalary(int month){
return salary+super.getSalary(month)+getPlusSalary();
}
public double getPlusSalary(){
return 1000;
}
}
class HourlyEmployee extends Employee{
private double salaryPerHour;
private int hours;
public HourlyEmployee(String name, int month, double salaryPerHour, int hours) {
super(name, month);
this.salaryPerHour = salaryPerHour;
this.hours = hours;
}
public double getSalary(int month){
double r=0;
if (hours>160){
r=160*this.salaryPerHour+(hours-160)*1.5*this.salaryPerHour;
}
else {
r=this.hours*this.salaryPerHour;
}
return r+super.getSalary(month);
}
}
class SalesEmployee extends Employee implements Plusable{
private double rate;
private int sales;
public SalesEmployee(String name, int month, double rate, int sales) {
super(name, month);
this.rate = rate;
this.sales = sales;
}
public double getSalary(int month){
return rate*sales+super.getSalary(month)+getPlusSalary();
}
public double getPlusSalary(){
return 100;
}
}
class BasePlusSalesEmployee extends SalesEmployee{
private double baseSalary;
public BasePlusSalesEmployee(String name, int month, double rate, int sales, double baseSalary) {
super(name, month, rate, sales);
this.baseSalary = baseSalary;
}
public double getSalary(int month){
return baseSalary+super.getSalary(month);
}
}
=======
2. 相当于一个标准,实现解藕合,把接口的使用者与实现者分开
//判断一个数是不是合数,是合数的打印出其质数积的形式
// 定义了两个接口
// Prime.java
public interface Prime{
boolean isPrime(int i);
}
// FenJie.java
public interface FenJie{
void print(int i);
}
// FenJieImpl.java 实现接口 FenJie
public class FenJieImpl implements FenJie{
Prime p;
public FenJieImpl(Prime p){
this.p=p;
}
public void print(int i){
for(int j=2;j<=i/2;j++){
if (i%j==0 && p.isPrime(j)){
int k=i/j;
if (p.isPrime(k)){
System.out.println(j+"*"+k);
}
else{
System.out.print(j+"*");
print(k);
}
break;
}
}
}
}
//PrimeImpl.java 实现接口Prime
public class PrimeImpl implements Prime{
public boolean isPrime(int i){
for(int j=2;j<i;j++){
if (i%j==0) return false;
}
return true;
}
}
// Print.java 使用接口
public class Print{
public static void main(String[] args){
Prime p=new PrimeImpl();
FenJie f=new FenJieImpl(p);
MyClass mc=new MyClass(p,f);
mc.business();
}
}
// 使用接口
class MyClass{
Prime p;
FenJie f;
public MyClass(Prime p,FenJie f){
this.p=p;
this.f=f;
}
public void business(){
for(int i=2;i<=100;i++){
if (!(p.isPrime(i))){
System.out.print(i+"=");
f.print(i);
}
}
}
}
3. 接口的回调
代码：
--------------------------------------------------------------------------------
---------------
// WorldCupCountry.java 定义接口
public interface WorldCupCountry{
void kaimushi();
void xiaozusai();
void taotaisai();
void juesai();
}
// WorldCupCountry.java 实现接口
public class USA implements WorldCupCountry{
public void kaimushi(){
System.out.println("德国－玻利维亚");
}
public void xiaozusai(){
System.out.println("沙特黑马");
}
public void taotaisai(){
System.out.println("保加利亚");
}
public void juesai(){
System.out.println("巴西");
}
}
// Germany.java 实现接口
public class Germany implements WorldCupCountry{
public void kaimushi(){
System.out.println("德国－哥斯达黎加");
}
public void xiaozusai(){
System.out.println("强者恒强");
}
public void taotaisai(){
System.out.println("四强全欧");
}
public void juesai(){
System.out.println("意大利");
}
}
// IFFO.java 使用接口
public class FIFA{
public static void main(String[] args){
WorldCupCountry c=new USA();
act(c);
}
public static void act(WorldCupCountry c){
c.kaimushi();
c.xiaozusai();
c.taotaisai();
c.juesai();
}
}
Object 类
toString() , equals() 方法的使用
================
代码：
--------------------------------------------------------------------------------
public class TestObject{
public static void main(String[] args){
/*
Student s=new Student("Liucy");
System.out.println(s);
*/
/*
String s1=new String("ABC");
String s2=new String("ABC");
System.out.println(s1==s2);
System.out.println(s1.equals(s2));
*/
Student s1=new Student("Liucy",30);
Student s2=new Student("Liucy",30);
System.out.println(s1.equals(s2));
}
}
class Student{
String name;
int age;
public Student(String name,int age){
this.name=name;
this.age=age;
}
//覆盖 toString() 方法,继承的该方法返回对像的字符串表现形式
public String toString(){
return "Student "+name;
}
// 覆盖 equals() 方法, 用来判断两个对象的值是否相等
public boolean equals(Object o){
if (this==o) return true;
if (o==null) return false;
if (!(o instanceof Student)) return false;
Student s=(Student)o;
if (this.age==s.age && this.name.equals(s.name)) return true;
else return false;
}
}
＝＝＝＝＝＝＝＝＝
day 07
===============
封装类
JAVA为每一个简单数据类型提供了一个封装类，使每个简单数据类型可以被Object来装载。
除了int（Integer）和char（Character），其余类型首字母大写即成封装类类型名。
转换字符的方式：
int I=10;
String s=I+” ”;
String s1=String.valueOf(i);
Int I=10;
Interger I_class=new integer(I);
封装类.字符串.基本类型
Interger--------------------(Double(x.toString))------------>Double
String -----------------(Integer.valueOf() )---------------->Integer
Integer-----------------(x.toString() )--------------------->String
int----------------------(100+””)------------------------->String
String------------------(Integer.parseInt() )--------------->int
Integer-----------------(Integer.intvalue() )--------------->int
学会查看javadoc的帮助文档。要先关注要使用方法的返回值类型，也就是要获得内容的类型，然后看方法名，JDK中的方法名基本上是见名知义，参数表，就是看需要什么才可以获得的需要的那些内容，也要看自己能够提供什么。
注意：“==”在任何时候都是比较地址，这种比较永远不会被覆盖。
程序员自己编写的类和JDK类是一种合作关系。（因为多态的存在，可能存在我们调用JDK类的情况，也可能存在JDK自动调
用我们的类的情况。）
注意：类型转换中double/interger/string之间的转换最多。
（注：所有使用内部类的地方都可以不用内部类，但使用内部类可以使程序更加的简洁，便于命名规范和划分层次结构）。
内部类是指在一个外部类的内部再定义一个类。
*内部类可为静态，可用PROTECTED和PRIVATE修饰。（而外部类不可以：顶级类只能使用PUBLIC和DEFAULT）。
*JAVA文件中没有publie class 可以类名和文件不同名。
内部类
内部类也就是定义在类内部的类。
内部类的分类
成员内部类、
局部内部类、
静态内部类、
匿名内部类（图形是要用到，必须掌握）。
成员内部类
四个访问权限修饰符都可以修饰成员内部类。
内部类和外部类在编译时时不同的两个类，内部类对外部类没有任何依赖。
内部类是一种编译时语法，在编译时生成的各自的字节码文件，内部类和外部类没有关系。
内部类中可以访问外部类的私有成员。
作为外部类的一个成员存在，与外部类的属性、方法并列。
内部类和外部类的实例变量可以共存。
在内部类中访问实例变量：this.属性
在内部类访问外部类的实例变量：外部类名.this.属性。
在外部类的外部访问内部类，使用out.inner.
成员内部类的特点：
1．内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为private，但是对于处于其内部的内部类还是可见的。）
2．用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。
对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。
3．成员内部类不能含有静态成员。
建立内部类对象时应注意：
在外部类的内部可以直接使用inner s=new inner();（因为外部类知道inner是哪个类，所以可以生成对象。）
而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象（外部类可用），然后在生成一个内部
类对象。内部类的类名是外部类类名.内部类类名。
Outer o=new Outer();
Outer.Inner in=o.new.Inner()。
静态内部类
（注意：前三种内部类与变量类似，所以可以对照参考变量）
静态内部类定义在类中，任何方法外，用static class定义。
静态内部类只能访问外部类的静态成员。
生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。
静态内部类的对象可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。静态内部类不可用private来进行定义
。
注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。
用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。
例子：
对于两个类，拥有相同的方法：
class People
{
run();
}
interface Machine{
run();
}
此时有一个robot类：
class Robot extends People implement Machine.
此时run()不可直接实现。
interface Machine
{
void run();
}
class Person
{
void run(){System.out.println("run");}
}
class Robot extends Person
{
private class MachineHeart implements Machine
{
public void run(){System.out.println("heart run");}
}
public void run(){System.out.println("Robot run");}
Machine getMachine(){return new MachineHeart();}
}
class Test
{
public static void main(String[] args)
{
Robot robot=new Robot();
Machine m=robot.getMachine();
m.run();
robot.run();
}
}
局部内部类
在方法中定义的内部类称为局部内部类。
与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。
注意：局部内部类不仅可以访问外部类私有实例变量，但可以访问外部类的局部常量（也就是局部变量必须为final的）
在类外不可直接访问局部内部类（保证局部内部类对外是不可见的）。
在方法中才能调用其局部内部类。
通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。
局部内部类写法
public class TestLocalInnerClass{
public static void main(String[] args){
Outer o=new Outer();
final int a=9;
o.print(a);
}
}
class Outer{
private int index=100;
public void print(final int a){
final int b=10;
System.out.println(a);
class Inner{
public void print(){
System.out.println(index);
System.out.println(a);
System.out.println(b);
}
}
Inner i=new Inner();
i.print();
}
}
匿名内部类
匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。
匿名内部类的特点：
1，一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
2，只是为了获得一个对象实例，不许要知道其实际类型。
3，类名没有意义，也就是不需要使用到。
注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名
。
因其为局部内部类，那么局部内部类的所有限制都对其生效。
匿名内部类是唯一一种无构造方法类。
大部分匿名内部类是用于接口回调用的。
匿名内部类在编译的时候由系统自动起名Out$1.class。
如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
因匿名内部类无构造方法，所以其使用范围非常的有限。
当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。
匿名内部类的写法：
interface A{
void ia();
}
class B{
public A bc(){
return new A{
void ia(){
}
};
}
}
使用匿名内部类：
B b=new B();
A a=b.bc();
a.ia();
Exception（例外/异常）
对于程序可能出现的错误应该做出预案。
例外是程序中所有出乎意料的结果。（关系到系统的健壮性）
JAVA会将所有的异常封装成为一个对象，其根本父类为Throwable。
异常的分类
Throwable有两个子类：Error和Exception。
一个Error对象表示一个程序错误，指的是底层的、低级的、不可恢复的严重错误。此时程序一定会退出，因为已经失去了
运行所必须的物理环境。对于Error错误我们无法进行处理，因为我们是通过程序来应对错误，可是程序已经退出了。
我们可以处理的Throwable类中只有Exception类的对象（例外/异常）。
Exception有两个子类：Runtime exception（未检查异常）可以在编程时避免，可处理可不处理
非Runtime exception（已检查异常）必须进行处理。
注意：无论是未检查异常还是已检查异常在编译的时候都不会被发现，在编译的过程中检查的是程序的语法错误，而异常是一个运行时程序出错的概念。
在Exception中，所有的非未检查异常都是已检查异常，没有另外的异常！！
未检查异常是因为程序员没有进行必要的检查，因为他的疏忽和错误而引起的异常。一定是属于虚拟机内部的异常（比如空指针）。
应对未检查异常就是养成良好的检查习惯。
已检查异常是不可避免的，对于已检查异常必须实现定义好应对的方法。
已检查异常肯定跨越出了虚拟机的范围。（比如“未找到文件”）
异常的传递
如何处理已检查异常（对于所有的已检查异常都要进行处理）：
首先了解异常形成的机制：
当一个方法中有一条语句出现了异常，它就会throw（抛出）一个例外对象（throw 异常对象），然后后面的语句不会执行
返回上一级方法，其上一级方法接受到了例外对象之后，有可能对这个异常进行处理，也可能将这个异常转到它的上一级。
注意：当一个方法中出现了异常，没有进行异常处理，方法就会把异常对象作为返回值返回。如果有异常进入虚拟机，那么虚拟机就会立刻中止程序的执行。
异常的处理方式
非RuntimeException （已检查异常）这种异常必须处理。如果不处理编译出错。
对于接收到的已检查异常有两种处理方式：throws和try..catch(...){}方法。
注意：出错的方法有可能是JDK，也可能是程序员写的程序，无论谁写的，抛出一定用throw。
在方法的定义中声明方法可能抛出的异常，用（throws 异常类名，异常类名） ，声明这个方法将不处理异常，并把异常交给上一级方法处理。可以抛出的是实际产生异常的父类的异常对象。
例：public void print() throws Exception.
对于方法a，如果它定义了throws Exception。那么当它调用的方法b返回异常对象时，方法a并不处理，而将这个异常对象
向上一级返回，如果所有的方法均不进行处理，返回到主方法，程序中止。（要避免所有的方法都返回的使用方法，因为这样出现一个很小的异常就会令程序中止）。
如果在方法的程序中有一行throw new Exception()，返回错误，那么其后的程序不执行。因为错误返回后，后面的程序肯
定没有机会执行，那么JAVA认为以后的程序没有存在的必要。
try..catch捕获异常
对于try……catch格式：
try {可能出现错误的代码块} catch(exception e){进行处理的代码} ；
对象变量的声明
用这种方法，如果代码正确，那么程序不经过catch语句直接向下运行；
如果代码不正确，则将返回的异常对象和e进行匹配，如果匹配成功，则处理其后面的异常处理代码。（如果用exception来声明e的话，因为exception为所有exception对象的父类，所有肯定匹配成功）。处理完代码后这个例外就完全处理完毕，
程序会接着从出现异常的地方向下执行（是从出现异常的地方还是在catch后面呢？利用程序进行验证）。最后程序正常退
出。
try块中的代码如果没有出现异常，就会跳过catch，正常执行。
try中如果发现错误，即跳出try块去匹配catch，那么try后面的语句就不会被执行。
一个try可以跟进多个catch语句，用于处理不同情况。当一个try只能匹配一个catch。
我们可以写多个catch语句，但是不能将父类型的exception的位置写在子类型的excepiton之前，因为这样父类型肯定先于
子类型被匹配，所有子类型就成为废话，java中是不允许写废话的，所以编译会出错。
在try，catch后还可以再跟一子句finally。其中的代码语句无论如何（无论有没有异常）都会被执行（因为finally子句的这个特性，所以一般将释放资源，关闭连接的语句写在里面）。finally中的代码在和try中的代码的冲突时，finally中的
代码一定会被执行且会忽略try中的代码。但是System.exit(0);(虚拟机退出语句)则不会去执行fianlly中的代码。
try{..}catch(..){..}
try{..}catch(..){}finally{..}
try{..}finally{}
以上三种写法都可以。
如果在程序中书写了检查（抛出）exception但是没有对这个可能出现的检查结果进行处理，那么程序就会报错。而如果只
有处理情况（try）而没有相应的catch子句，则编译还是通不过。
如何知道在编写的程序中会出现例外呢
1．调用方法，查看API中查看方法中是否有已检查错误。
2．在编译的过程中看提示信息，然后加上相应的处理。
Throwable有一个message属性。在使用catch的时候可以调用：
Catch(IOException e){System.out.println(e.message())};
Catch(IOException e){e.printStackTrace()};
以上两条语句都是可以打印出错的过程信息。告诉我们出错类型所历经的过程，在调试的中非常有用。
开发中的两个道理：
①如何控制try的范围：根据操作的连动性和相关性，如果前面的程序代码块抛出的错误影响了后面程序代码的运行，那么
这个我们就说这两个程序代码存在关联，应该放在同一个try中。
②对已经查出来的例外，有throw(消极)和try catch（积极）两种处理方法。
对于throws把异常抛到try catch能够很好地处理例外的位置（即放在具备对例外进行处理的能力的位置）。如果没有处理
能力就继续上抛。
当我们自己定义一个例外类的时候必须使其继承excepiton或者RuntimeException。
throw是一个语句，用来做抛出例外的功能。
而throws是表示如果下级方法中如果有例外抛出，那么本方法不做处理，继续向上抛出。
throws后跟的是例外类型。
注意：方法的覆盖中，如果子类的方法抛出的例外是父类方法抛出的例外的父类型，那么编译就会出错：子类无法覆盖父类。
结论：子类方法不可比父类方法抛出更多的例外。子类抛出的例外或者与父类抛出的例外一致，或者是父类抛出例外的子类型。或者子类型不抛出例外。如果父类型无throws时，子类型也不允许出现throws。此时只能使用try catch。
断言是一种调试工具（assert）
其后跟的是布尔类型的表达式，如果表达式结果为真不影响程序运行。如果为假系统出现低级错误，在屏幕上出现assert信息。
Assert只是用于调试。在产品编译完成后上线assert代码就被删除了。
代码：
--------------------------------------------------------------------------------
内部类
1. 成员内部类
--------
public class TestMemberInnerClass{
public static void main(String[] args){
Outer out=new Outer();
Outer.Inner in=out.new Inner();
in.print();
}
}
class Outer{
private int index=200;
class Inner{
private int index=100;
public void print(){
int index=50;
System.out.println(index);
System.out.println(this.index);
System.out.println(Outer.this.index);
}
}
}
2. 静态内部类
---------------
public class TestStaticInnerClass{
public static void main(String[] args){
Outer.Inner in =new Outer.Inner();
in.print();
}
}
class Outer{
private static int index=100;
static class Inner{
private int index=50;
public void print(){
System.out.println(index);
System.out.println(Outer.index);
}
}
}
3. 局部内部类
-------------
public class TestLocalInnerClass{
public static void main(String[] args){
Outer out=new Outer();
out.print(10);
}
}
class Outer{
private int index=100;
public void print(final int a){
final int b=20;
class Inner{
public void method(){
System.out.println(index);
System.out.println(a);
System.out.println(b);
}
}
Inner in=new Inner();
in.method();
}
}
----------------
必需使用内部类的情况: 父类与接口中的方法命名冲突时
public class TestRobot{
public static void main(String[] args){
Robot r=new Robot();
r.run();
r.getHeart().run();
}
}
abstract class People{
abstract void run();
}
interface Machine{
void run();
}
class Robot extends People{
class Heart implements Machine{
public void run(){
System.out.println("发动机运行");
}
}
public Machine getHeart(){
return new Heart();
}
public void run(){
System.out.println("机器人跑");
}
}
--------------------
代码：
--------------------------------------------------------------------------------
局部内部类经常配合接口使用,来强制实现弱藕合,强制实现者针对接口编程
------------
public class TestInnerClass{
public static void main(String[] args){
//Teacher t=Tarena.getTeacher("CoreJava");
//t.teach();
/*
Liuxf t=new Liuxf();
t.teach();
*/
Tarena.run(new Teacher(){
public void teach(){
System.out.println("HeHe");
}
});
}
}
interface Teacher{
void teach();
}
class Tarena{
/*
public static Teacher getTeacher(String course){
class Liuxf implements Teacher{
public void teach(){
System.out.println("多讲项目经验");
}
}
class Huxz implements Teacher{
public void teach(){
System.out.println("重在思想，重在理解，强调编码能力");
}
}
if (course.equals("CoreJava")) return new Huxz();
else return new Liuxf();
}
*/
public static Teacher getTeacher(String course){
if (course.equals("CoreJava")){
return new Teacher(){
public void teach(){
System.out.println("CoreJava Teacher");
}
};
}
else {
return new Teacher(){
public void teach(){
System.out.println("OtherTeacher");
}
};
}
}
public static void run(Teacher t){
t.teach();
}
}
---------------------
封装类:
public class TestInteger{
public static void main(String[] args){
int i=12;
Integer ii=new Integer(i);
int i2=ii.intvalue();
String s=String.valueOf(i);
String s2=i+"";
int i3=Integer.parseInt(s);
String s3=ii.toString();
Integer ii2=Integer.valueOf(s3);
}
}
--------------
异常处理:
1. runtimeException
public class TestRuntimeException{
public static void main(String[] args){
/*
double a=1;
double b=0;
System.out.println(a/b);
*/
/*
int[] a=new int[3];
int i=2;
if (i>=0 && i<a.length) System.out.println(a[i]);
*/
/*
Animal a=new Dog();
if (a instanceof Cat) Cat c=(Cat)a;
*/
Animal a=null;
a.eat();
}
}
class Animal{
public void eat(){}
}
class Dog extends Animal{}
class Cat extends Animal{}
---------
代码：
--------------------------------------------------------------------------------
-----------
非 runtimeException
import java.io.*;
import java.sql.*;
import java.net.*;
public class TestException{
public static void main(String[] args){
System.out.println("Main 1");
int i=Integer.parseInt(args[0]);
ma(i);
System.out.println("Main 2");
}
public static void ma(int a){
System.out.println("MA 1");
try{
mb(a);
System.out.println("MA 2");
}
catch(SQLException e){
e.printStackTrace();
}
catch(IOException e){
e.printStackTrace();
}
catch(MyException e){
e.printStackTrace();
}
catch(Exception e){
e.printStackTrace();
}
finally{
System.out.println("Finally");
}
System.out.println("MA 3");
}
public static void mb(int a) throws SQLException,IOException,MyException{
System.out.println("MB 1");
mc(a);
System.out.println("MB 2");
}
public static void mc(int a)throws EOFException,SocketException,SQLException,MyException{
System.out.println("MC 1");
if (a==0) throw new NullPointerException("空指针");
if (a==1) throw new EOFException("文件结束异常");
if (a==2) throw new SocketException("套接字异常");
if (a==3) throw new SQLException("数据库异常");
if (a==4) throw new MyException("我自定义的异常");
System.out.println("MC 2");
}
}
class MyException extends Exception{
public MyException(String message){
super(message);
}
public MyException(){}
}
---------
finally 的用法
public class TestFinally{
public static void main(String[] args){
System.out.println(fn(1));
System.out.println(fn(0));
System.out.println(fn(2));
}
public static int fn(int b){
try{
return 2/b;
}
catch(Exception e){
return 0;
}
finally{
if (b==2) return 2;
}
}
}
----------------
day 08
================
集合类
集合类的对象是用来管理其他若干对象的，它类似于C++标准模板库中的容器，不过在JAVA的集合类的对象中可以用来存放多种类型的对象。
接口和类共同构成了一个集合框架，集合的概念，一个对象可以装载多个对象，这个对象就是集合对象。
集合框架
1，接口
Collection 用来管理多个对象，集合中的每个元素都是对象。
Map，Map中没有对象，而是键值对，由Key，value组成的键值对，Key是不可重复的。value是可以相同的,一个Key和一
个value一一对应。
集合中用到的类，接口在java.util包中，在使用时注意将其引入import。
Collection 接口（以下介绍其子接口）
1)List 一个List的实现类的对象在管理多个对象时会按顺序组织对象（即按照将对象放入的顺序存储），List实现类的对象是由顺序的。（注意，顺序和排序的区别）
2)Set 一个Set的实现类表示一个数学概念上的集合，Set的实现类的对象中的元素是无顺序的，也就是不会按照输入顺
序来存放，Set的实现类对象中的元素是不重复的。
3)SortedSet,他是Set的子接口，他的实现类会对集合中的元素进行排序。但是要指定排序规则，他会按排序规则进行排序。
Map 接口（以下介绍其子接口）
SortedMap，这个接口的实现类同样可以实现，不过是对键值对中的Key进行排序，这个接口的实现类也是要指定排序规
则的。
JDK1.4中的集合是不安全的对象，JDK5.0中解决了这个问题。
List接口的实现类
1> ArrayList是接近于功能的集合类，ArryList的实质就是一个会自动增长的数组，ArrayList是用封装的数组来实现的List接口的。
Collection的实现类对象的遍历方式是用迭代来实现的。
在使用迭代器时先要活得一个迭代器的对象，Iterator（迭代器接口）这是一个接口，迭代器是在集合类中实现的，也
就是说，他是一个内部类（匿名内部类）实现的。
Iterator接口中定义的常用方法方法hasNext()，next()。
hasNext(),这个方法会使用一个游标，并通过判断游标指向的位置是否存放有对象。
next()方法也是Iterator接口中定义好的方法，这个方法会使游标指向下一个元素的位置，游标会跳过第一个元素，并
返回其中的内容。
Collections 这是一个工具类，也是java.util包中的，这个类中的sort(list接口的实现类的对象)方法，其参数是一个集合类的对象，这个方法使用来对集合类的对象进行排序的。以后，我将以集合这个名字来称呼集合类的对象。，对于
字符串对象内容的集合来说会按字典顺序排序（升序），对于数字内容的集合排序也会按照升序排序。
排序可一份为两部分内容，一个是排序的规则，也就是按照什么来进行排序，并且排成什么样的顺序。
第二个就是排序的算法，他决定了排序的效率。
在对自定义的集合内容类型排序时，需要先定义那个类型的排序规则。
Comparable接口，这个接口中只定义了一个compareTo(Object o)，方法的返回至类型是整型，如果当前对象大于参数对象就返回正数，当前对象等于参数对象是就返回0，当前对象小于参数对象时就返回负值，这样写就是升序排列，反之则是进行降序排列，在实现这个接口中的方法时，返回值定义方式，只有这两种。
根据指定类型的排序规则实现了Comparable接口，那么就可以对存有这个类型的集合进行整体排序。Comparable接口，
也叫做可比较接口。这个接口在java.lang包下。只要实现了这个接口，就是可排序的。
接下来介绍另外一种对自定义类型对象的集合整体排序的方法，也就是实现比较器接口（Comparator），这个接口中定
义了一个compare(Object o1，Object o2)方法来比较两个对象，这个方法的返回值定义和上面介绍的那个方法是一样。
注意：在API，帮助文档中以上两个方法的参数类型是T，这代表的模板类型，也就是集合中存放的内容的类型，在JDK1.4中其参数就是Object类型，模板类型的详细内容会在最后的JDK5.0新特性中讲到。
Comparator接口可以在匿名内部类中实现，Collections 中的sort(集合了的对象，比较器)方法，可以对自定义类型内
容的集合进行整体排序。
2> LinkedList，它是List接口的实现类，其底层是用双向循环链表来实现的。
注意：ArrayList的查询效率比较高，增删动作的效率比较差，适用于查询比较频繁，增删动作较少的元素管理的集合。
LinkedList的查询效率低，但是增删效率很高。适用于增删动作的比较频繁，查询次数较少的元素管理集合。
ArrayList，LinkedList都是线程不安全的。
实现堆栈 1，数组（ArrayList，增删效率比较低，不适合）
2，LinkedList（实现堆栈的好方法）
3，java.util.Stack类，Stack是Vector的子类，Vector类是一个线程安全的（是一个重量级的类），并继承
了Vector的方法，Verctor类和ArrayList的功能近乎相同。（不推荐使用Stack类来实现堆栈）。
Set接口的实现类
HashSet
Set的实现类的集合对象中不能够有重复元素，HashSet也一样他是使用了一种标识来确定元素的不重复，HashSet用一种算法来保证HashSet中的元素是不重复的，HashSet的底层实现还是数组。
Object类中的hashCode()的方法是所有子类都会继承这个方法，这个方法会用Hash算法算出一个Hash（哈希）码值返回
，HashSet会用Hash码值去和数组长度取模，模（这个模就是对象要存放在数组中的位置）相同时才会判断数组中的元素和要加入的对象的内容是否相同，如果不同才会添加进去。
Hash算法是一种散列算法。
注意：所以要存入HashSet的集合对象中的自定义类必须覆盖hashCode(),equals()两个方法，才能保证集合中元素容不
重复。在覆盖和hashCode()方法时，要使相同对象的hashCode()方法返回相同值，覆盖equals()方法再判断其内容。为
了保证效率，所以在覆盖hashCode()方法时，也要尽量使不同对象尽量返回不同的Hash码值。
如果数组中的元素和要加入的对象的hashCode()返回了相同的Hash值（相同对象）,才会用equals()方法来判断两个对象的内容是否相同。
SortedSet接口是Set的子接口。
TreeSet是SortedSet接口的实现类，他可以对集合中的元素进行排序。
要存放在TreeSet中自定义类的对象，这个类要么是已经实现了Comparable接口，要么是能给出Comparator比较器，TreeSet可以自动过滤掉重复元素所以不用重载hashCode()方法，TreeSet会根据比较规则判断元素内容是否相同，TreeSet会在元素存入世就进行了排序。（在TreeSet给出排序规则时，一定要注意对象内容相等的条件，一定要注意在主观的认为两个对象内容相同时，才可以使用比较少的条件来进行判断）
在要排序时才使用TreeSet类（存储效率比较低），HashSet的存储效率比较高，在需要为HashSet的对象排序时，就可以把HashSet中的元素放入TreeSet。
========================
代码：
--------------------------------------------------------------------------------
1. Exception 应用
----------------
public class TestLoginException {
public static void main(String[] args) {
UserManagement u=new UserManagement();
try {
System.out.println(u.login("Huxz","1234"));
} catch (UserNameException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (PasswordException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
System.out.println(u.login("Liucy","1250"));
} catch (UserNameException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (PasswordException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
System.out.println(u.login("TangLiang","1234"));
} catch (UserNameException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (PasswordException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
class UserManagement{
String[] users={"Huxz","Liucy","Chenzq"};
String[] pwds={"1234","5678","1250"};
public String login(String name,String pwd) throws UserNameException,PasswordException{
for(int i=0;i<users.length;i++){
if (users[i].equals(name)){
if (pwds[i].equals(pwd)){
return "WelCome";
}
else{
throw new PasswordException("密码错误！");
}
}
}
throw new UserNameException("用户名不存在");
}
}
class UserNameException extends Exception{
public UserNameException() {
super();
}
public UserNameException(String msg) {
super(msg);
}
}
class PasswordException extends Exception{
public PasswordException() {
super();
}
public PasswordException(String arg0) {
super(arg0);
}
}
2. 断言 应用示例
-------------
public class TestAssertion{
public static void main(String[] args){
int i=Integer.parseInt(args[0]);
assert i==1:"ABCDEFG";
System.out.println(i);
}
}
3. ArrayList 应用举例, 结合Colletions.sort()
-------------------------
import java.util.*;
public class TestArrayList {
public static void main(String[] args) {
List l=new ArrayList();
/*
l.add("ABC");
l.add("DEF");
l.add("ABC");
l.add(1,"Liucy");
*/
/*
l.add("Liucy");
l.add("Chenzq");
l.add("Hiloo");
l.add("TangLiang");
l.add("Huxz");
*/
/*
l.add(new Integer(10));
l.add(new Integer(12));
l.add(new Integer(6));
*/
Student s1=new Student("Liucy",40);
Student s2=new Student("Chenzq",38);
Student s3=new Student("TangLiang",18);
l.add(s1);
l.add(s2);
l.add(s3);
Collections.sort(l);
/*
System.out.println(l.size());
String s=(String)l.get(1);
System.out.println(s);
*/
/*
for(int i=0;i<l.size();i++){
Object s=l.get(i);
System.out.println(s);
}
*/
print(l);
}
public static void print(Collection c){
Iterator it=c.iterator();
//System.out.println(it.getClass().getName());
while(it.hasNext()){
Object o=it.next();
System.out.println(o);
}
}
}
class Student implements Comparable{
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "Student "+name+" "+age;
}
public int compareTo(Object o){
Student s=(Student)o;
return this.name.compareTo(s.name);
}
}
class Collections2{
public static void sort(List l){
for(int i=0;i<l.size()-1;i++){
for(int j=i+1;j<l.size();j++){
Object o1=l.get(i);
Object o2=l.get(j);
Comparable c1=(Comparable)o1;
Comparable c2=(Comparable)o2;
if (c1.compareTo(c2)>0){
Collections.swap(l,i,j);
}
}
}
}
}
代码：
--------------------------------------------------------------------------------
4.LinkedList 实现堆栈
---------------------
import java.util.*;
public class TestStack {
public static void main(String[] args) {
MyStack ms=new MyStack();
ms.push("Chenzq");
ms.push("Liucy");
ms.push("BaiLu");
System.out.println(ms.pop());
System.out.println(ms.pop());
System.out.println(ms.pop());
}
}
class MyStack{
private LinkedList ll=new LinkedList();
public void push(Object o){
ll.addFirst(o);
}
public Object pop(){
return ll.removeFirst();
}
}
5. HashSet 应用
----------------
import java.util.*;
public class TestHashSet {
public static void main(String[] args) {
Set s=new HashSet();
/*
String s1=new String("Liucy");
String s2=new String("Chenzq");
String s3=new String("Hiloo");
String s4=new String("TangLiang");
String s5=new String("Huxz");
String s6=new String("Liucy");
*/
TarenaStudent s1=new TarenaStudent("Liucy",30);
TarenaStudent s2=new TarenaStudent("Chenzq",32);
TarenaStudent s3=new TarenaStudent("Hiloo",35);
TarenaStudent s4=new TarenaStudent("TangLiang",18);
TarenaStudent s5=new TarenaStudent("Huxz",16);
TarenaStudent s6=new TarenaStudent("Liucy",30);
s.add(s1);
s.add(s2);
s.add(s3);
s.add(s4);
s.add(s5);
s.add(s6);
print(s);
}
public static void print(Collection c){
Iterator it=c.iterator();
while(it.hasNext()){
Object o=it.next();
System.out.println(o);
}
}
}
-----
public class TarenaStudent implements Comparable {
String name;
int age;
public TarenaStudent(String name, int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "Student "+name+" "+age;
}
/*
public boolean equals(Object o){
System.out.println("Run Equals") ;
if (this==o) return true;
if (o==null) return false;
if (!(o instanceof TarenaStudent)) return false;
TarenaStudent ts=(TarenaStudent)o;
if (this.age==ts.age && this.name.equals(ts.name)) return true;
else return false;
}
public int hashCode(){
return age+name.hashCode();
}
*/
public int compareTo(Object o){
TarenaStudent ts=(TarenaStudent)o;
if (this.age!=ts.age) return this.age-ts.age;
else return this.name.compareTo(ts.name);
}
}
6. SortedSet 接口中的 TreeSet 类的应用
------------------
import java.util.*;
public class TestTreeSet {
public static void main(String[] args) {
SortedSet s=new TreeSet();
TarenaStudent s1=new TarenaStudent("Liucy",30);
TarenaStudent s2=new TarenaStudent("Chenzq",32);
TarenaStudent s3=new TarenaStudent("Hiloo",30);
TarenaStudent s4=new TarenaStudent("TangLiang",18);
TarenaStudent s5=new TarenaStudent("Huxz",16);
TarenaStudent s6=new TarenaStudent("Liucy",30);
s.add(s1);
s.add(s2);
s.add(s3);
s.add(s4);
s.add(s5);
s.add(s6);
print(s);
}
public static void print(Collection c){
Iterator it=c.iterator();
while(it.hasNext()){
Object o=it.next();
System.out.println(o);
}
}
}
day09
================
代码：
--------------------------------------------------------------------------------
1. HashMap 实现Map接口
import java.util.*;
public class TestHashMap {
public static void main(String[] args) {
Map m=new TreeMap();
m.put("Unix","Hiloo");
m.put("CoreCpp","Chenzq");
/*
System.out.println(m.put("UC","Liucy"));
System.out.println(m.put("UC","Chenzq"));
System.out.println(m.size());
System.out.println(m.get("UC"));
*/
m.put("UC","Liucy");
m.put("CoreJava","TangLiang");
m.put("CoreJava","Huxz");
//m.put(null,null);
print(m);
}
public static void print(Map m){
Set keySet = m.keySet();
Iterator it=keySet.iterator();
while(it.hasNext()){
Object key=it.next();
Object value=m.get(key);
System.out.println(key+"--"+value);
}
}
}
class HashSet2{
private HashMap hm=new HashMap();
public void add(Object o){
hm.put(o,null);
}
}
2. 综合应用举例
--------------
题目:
Exam类 考试类
属性： 若干学生 一张考卷
提示：学生采用ArrayList存放
Paper类 考卷类
属性：若干试题
提示：试题采用HashMap存放，key为String，表示题号，value为试题对象
Student类 学生类
属性：姓名 一张答卷 一张考卷
Question类 试题类
属性：题号 题目描述 若干选项 正确答案 多选
提示：若干选项用ArrayList
AnswerSheet类 答卷类
属性：每道题的答案
提示：答卷中每道题的答案用HashMap存放，key为String，表示题号，value为学生的答案
问题：为Exam类添加一个方法，用来为所有学生判卷，并打印成绩排名（名次、姓名）
代码：
--------------------------------------------------------------------------------
编程实现:
import java.util.*;
public class TestExam {
public static void main(String[] args) {
Exam exam=new Exam();
Paper paper=new Paper();
exam.paper=paper;
Student.paper=paper;
Question q1=new Question();
q1.questionId="Q01";
q1.answers.add("A");
q1.answers.add("B");
Question q2=new Question();
q2.questionId="Q02";
q2.answers.add("A");
q2.answers.add("B");
q2.answers.add("C");
Question q3=new Question();
q3.questionId="Q03";
q3.answers.add("B");
paper.questions.put(q1.questionId,q1);
paper.questions.put(q2.questionId,q2);
paper.questions.put(q3.questionId,q3);
Student s1=new Student();
s1.name="Liucy";
Set s=new HashSet();
s.add("A");
s.add("B");
s1.as.myAnswers.put(q1.questionId,s);
s=new HashSet();
s.add("A");
s.add("B");
s.add("C");
s1.as.myAnswers.put(q2.questionId,s);
s=new HashSet();
s.add("A");
s.add("B");
s1.as.myAnswers.put(q3.questionId,s);
exam.students.add(s1);
Student s2=new Student();
s2.name="Chenzq";
s=new HashSet();
s.add("A");
s.add("B");
s.add("C");
s2.as.myAnswers.put(q1.questionId,s);
s=new HashSet();
s.add("A");
s.add("B");
s2.as.myAnswers.put(q2.questionId,s);
s=new HashSet();
s.add("B");
s2.as.myAnswers.put(q3.questionId,s);
exam.students.add(s2);
Student s3=new Student();
s3.name="Huxz";
s=new HashSet();
s.add("A");
s.add("B");
s3.as.myAnswers.put(q1.questionId,s);
s=new HashSet();
s.add("A");
s.add("B");
s.add("C");
s3.as.myAnswers.put(q2.questionId,s);
s=new HashSet();
s.add("B");
s3.as.myAnswers.put(q3.questionId,s);
exam.students.add(s3);
exam.print();
}
}
class Exam{
Paper paper;
//element:Student
List students=new ArrayList();
public void print(){
Collections.sort(students);
int i=1;
Iterator it=students.iterator();
while(it.hasNext()){
Student s=(Student)(it.next());
System.out.println(i+":/t"+s);
i++;
}
}
}
class Paper{
//key:questionID value:Question
Map questions=new HashMap();
}
class Question{
String questionId;
String desc;
//element:String
List chooses=new ArrayList();
//element:String such as "A" "B"
Set answers=new HashSet();
}
class Student implements Comparable{
String name;
AnswerSheet as=new AnswerSheet();
static Paper paper;
public int compareTo(Object o){
Student s=(Student)o;
if (this.getMark()<s.getMark()) return 1;
else if (this.getMark()>s.getMark()) return -1;
else return name.compareTo(s.name);
}
//得到学生成绩 判卷子
public double getMark(){
double c=0;
Map questions=paper.questions;
//所有的题号
Set qIds=questions.keySet();
Iterator it=qIds.iterator();
while(it.hasNext()){
String qId=(String)it.next();
Question q=(Question)questions.get(qId);
Set cAnswers=q.answers;
Set myAnswers=(Set)as.myAnswers.get(qId);
if (isSetEquals(cAnswers,myAnswers)){
c++;
}
}
return c/qIds.size()*100;
}
//判断两个Set是否相等
private boolean isSetEquals(Set s1,Set s2){
if (s1.size()!=s2.size()) return false;
Iterator it=s1.iterator();
while(it.hasNext()){
Object o=it.next();
if (!(s2.contains(o))) return false;
}
return true;
}
public String toString(){
return name+" "+getMark();
}
}
class AnswerSheet{
//key:String questionID
//value:Set
Map myAnswers=new HashMap();
}