java中有些概念不清的东东

话题一：变量
1：局部变量：在某个方法里面声明的变量
注意：◆一定要先赋值，再使用。
   ◆作用范围是定义它的代码块，{}
   ◆两个局部变量在同一范围内不能命名冲突
2：实例变量：某个对象的非静态属性
◆如果没有给它进行赋值，系统可以对它进行默认赋值，默认值也可以使用（与局部变量的区别）
◆一个局部变量和实例变量在同一个范围内，可以命名冲突，并且局部变量覆盖实例变量
class c{
int a=10;
public void m(){
a=20;
System.out.println(a);       //输出20
}
}
3：类变量：某个类的用static 修饰的属性（静态属性）
只初始化一次，多个类共有一份。

话题二：数组
1：计算机中的三个空间
◆栈空间: 临时变量，引用类型的变量
◆堆空间：对象存储区。
◆代码空间（方法空间）：类的描述信息
注意：用new申请的空间都是在堆空间里面的。所有的类和对象都放在堆里面，如果只是一个引用，那么只在栈空间中给开辟一个存放地址的空间。
例如：A  a =new A();  
那么a 在栈空间，A的代码在方法空间，对象在堆空间。
2: 数组：一个数组本质上就是一个对象。
（1）Person [] p ;声明一个数组的引用时候并没有创建一个对象。
注意：声明一个引用的时候，不能加上长度。例如：
Person [10]p ：就是错误的。
（2）Person  []a=new Person [100]; 给这个数组在堆空间中申请空间。但是各个元素还需要重新赋值。
例如：a[0]=new Person();
3: 如果只是声明没有初始化的时候，系统会为每个元素给一个默认的初始值
◆Int  : 0 
◆boolean : false
◆Float/double : 0.0
◆Char  : ‘\u 0000’
◆String : null

话题三：方法重载和覆盖
1：重载（overload ）：
（1）要求：方法名相同，参数列表不同。别的一概不考虑
（2）发生范围：同一个类或父子类之间都可以有方法重载的实现。
父子类的实现，例如：
class  A{
Public  void  m(long a ){}
}
Class B extends A {
Public void m(int a ){}
}
2：覆盖(override)：
（1）发生范围：父子类之间；
（2）要求：名字，参数列表，返回值相同，修饰符号可见范围扩展。

话题四：参数的传递
1：基本数据类型：值传递
2：对象类型：引用传递和值传递结合
public class Test1 {
public static void test1(String str){
str="world";
}
public static void test2(Animal a){
//a=new Animal();
a.setAge(10);
}
public static void main(String[] args) {
//测试String类
String string="hello";
test1(string);
System.out.println(string);
//测试普通的自定义类
Animal an=new Animal (20);
test2(an);
System.out.println(an.age);
}
}
/**对于引用变量本身来说，是一种值传递，即引用不能再指向另外一个对象，对于引用所指向的对象来书，又是一种引用传递，这个对象的属性可以改变*/
class Animal{
int age;
Animal(){}
Animal(int age){
this.age=age;
}
public void setAge(int age) {
this.age = age;
}
}

注意：只有用new关键字的时候才是创建了一个新的对象，否则    只是取得了一个对这个对象的引用。例如：
Student a =new student ;//创建了一个对象
b=a ;//只是声明了一个引用
3：string 类,stringBuffer ,StringTokenizer
（１）:String :
系统为我们提供的不可变类型，内容是不变的，
优点：可以共用
缺点：不停的创建新的对象，
解决方案：用stringbuffer 替代。
（２）：StringBuffer：带缓冲的字符串对象，对象是可以修改的
（３）：Stringtokenizer：String的工具类，用于根据分隔符将字符串分隔成字符串的数组。是出于兼容性的原因而被保留的遗留类（不鼓励使用）。

话题五：java 的三大特性（封装，继承，多态）
一：封装（encapsulation）：
二：继承：(inheritance)
1：书写方式：class A extends C{}
2：原则：把公共的特点抽象出来放在父类里面，一个类只能由一个父类。
3：权限：
◆Public:  公开  可以继承
◆Default: 本类＋同包    子类若与父类同包则可以继承
◆Protected:本类＋同包＋不同包子类 可以继承
◆Private:本类内部访问  不会继承
注意：属性和方法可以被继承，但是构造方法不能被继承
4 ：不用继承实现方法的扩散，(委托模式)
Class  C{
Public void m(){}
}
Class    A{
C  c=new  C();
}
A把拥有这个方法的类C作为自己的属性,那么当调用A的m()的时候，A就可以调用C的m()方法.
调用的书写方式：A.C.m();

三：多态(polymorphism) （统一管理）
1：弄明白互相赋值许可：（同样影响强制类型转换的原因）
子类可以赋值给父类，但是父类不能赋值给子类
例如:       Animal  c=new Dog();

评论

4 楼 meohao 2010-08-28  

１：List: 是有顺序(加入的顺序) 的，用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。可以重复；
２：Set：（集合）无顺序的，元素不可以重复。
３：ArrayList：特点：轻量级的  用数组实现的（可以用下标进行删除和查找），线程不安全，查询快，增删慢（实现搜索引擎的最优选择）.
４：LinkedList：双向循环链表实现，查询慢，增删快（实现栈的最优选择）
５：Vector：数组实现，重量级的。线程安全
６：HashSet：无序的
判断相同对象的步骤：
（1）：覆盖这个对象的hashCode()方法，自己规定什么时候hashCode 相同，
（2）：覆盖equals()方法。
注意：不同的对象也由可能有相同的hashCode，这个我们不能避免，但是应该尽可能使相同的对象有相同的hashCode。
７：TreeSet：有序的
要求每一个对象都要实现Comparable接口，并且覆盖comparaTo()方法
没有利用hashCode来判断，只是根据排序规则，来进行判断两个对象是否相同，
8：SortedSet：按照某一个规则对Set进行排序
9：Collections(工具类)
跟Collection没有关系，主要提供一些操作colletion子类对象的方法。
10：特例：容器中装容器
每个Collecton 都有一个addAll()方法，可以把一个集合完全装载到另外一个集合里面：例如：
　　　　Set set=new Set();
  List ls=new List();
  Ls.addAll(set);//把Set装载在list里面。
三：管理的每个元素是两个对象的容器（ＭＡＰ）

１；Map定义(key--value) ： 通过一个key值得到一个value ，一般用作八种基本类型和字符串作为一个map 集合的key值,key值不能重复
２：SortedMap: 一般是按照key值得升序排序，如果需要自己规定，那么就需要key对象所对应的类覆盖comparable接口。
2：HashMap（实现类）:对key保持唯一。如果用自定义的key，那么就要覆盖hashclode() 和equals()方法;
3：HashTable:（实现类）：
4：二者比较：
HashMap轻量级的，线程不安全，键值可以有空指针。
　　　HashTable：重量级的，线程安全的，键值都不能有空指针。
5：properties:
主要是用来存取配置文件的信息。本质上两个参数都是一个字符串型的。
6：实现comparable ，comparator的区别
例子：
Set set =new HashSet(new IMComparator());
使用限制：这个容器如果再装载别的类型的时候，这个比较器就没有作用了。
Class Student implements Comparable{}
本章学习方向：熟练使用ＡＰＩ，记住常用的几个容器及其特点


话题十一：异常（exception）

一：异常处理：
1：目的：提高程序的容错性。而不是不让出错
2：异常类
二：常见的未检查异常
（1）：ArithmeticException
Int a /0： 整形除以0 是有异常的
注意： Double  a/0: 浮点型除以0是没有异常的，输出无穷大
（2）NullPointerException
  Animal a=null;
     a. toString ();
（3）IndexOutOfBoundsException
  int i[]=new int[3];
     System.out.print(i[3]);
（4）ClassCastException
  A a =new A();
     B b=(B)a;

三：异常的传递
异常时一级一级往上抛的。如果自己处理不了，就可以传递给上一级的方法。但是一旦抛给虚拟机之后，虚拟机或者程序就会终止
抛异常用的是：throw 关键字
四：异常的处理
1：throws（消极处理机制）
方法声明的一部份，表示如果在这个方法里面出现了这个异常，不进行处理就往上一级抛 ，
例如：Public static int m() throws EOFException{}
特点：（１）可以抛出多个异常。
　（２）所有的方法都可以抛出异常
  （3）如果没有写，系统会默认为往上一级抛出
注意：Throws和 throws 的区别：
   Throw ：是一个动作，一定跑出一个异常。
   Throws :只是一个声明，不一定就跑出异常，
2: try {}catch{}finally{}
（1）Try({} 把可能出现异常的语句包起来，如果出现了异常，就跳出这个try {} 语句块，到后边处理这种异常的地方俱虚处理，如果一直没有处理，就抛给了上级
（2）catch{}语句用来捕获异常，Try {} 后面可以跟多个catch{}
（3）前面的catch{} 捕获的异常，应该是后边catch{}语句捕获异常的子类，否则编译通不过（JAVA不允许出现废话） 
（4）finally{}的代码不管出不出异常，都会执行。
   作用：这个语句一般用来释放资源 。
（5）这三个代码块可以互相嵌套
（6）常用形式
  try{}catch{}
  try{}catch{}finally{}
  try {}finally{}//用在throws 异常的地方
（7）catch{}语句里面一般对异常的处理
Exception e=new Exception(“出错”);
e.getMessage();//打印出“出错”
e.printStackTrace()；//打印出异常所属的类，以及异常信息，和跟踪的栈信息。
五：自定义异常
1：定义方式：让它继承类Throwable,或者Ecxception 或者RuntimeException
Class MyException  extends  Throwable{} 
注意：
（1）子类中覆盖方法不能跑出比父类中被覆盖方法更多的异常（多态）。
（2）java 不允许废话（永远也不可能被执行的语句）；

话题十二：Java 垃圾回收机制：
１：回收的对象：没有任何引用指向一个对象
２：回收的时机：不确定，不同的java 虚拟机的回收机制不同，没有统一的标准：
３：主动通知垃圾回收线程回收：
System.gc();通知垃圾回收站回收，但是回收不回收旧是JVM的事情。
Finalize()用来资源清理。

3 楼 meohao 2010-08-28  

如果需要复用或者共享部分的代码（各个子类都可以使用而不用自己重新定义），我们需要使用抽象类，（看下面的缺省适配模式）
6：Default adapter（缺省适配）模式：
（１）；定义：为接口提供一个抽象类，对接口中定义的所有方法都给出默认的实现，子类在实现接口的时候，可以选择继承这个抽象类，同样达到实现接口的目的，
（2）：优点：子类只用覆盖自己感兴趣的方法.，而不用写其他跟别的子类相同的代码。
（3）：缺点：失去了唯一的继承，不能再继承别的类。
例子：Interface A{
Public void m1();
Public void m2();
Public void m3();
Public void m4();
}
Abstract class B impelmentst A{
Public  void m1(){}
Public  void m2(){}
Public  void m3(){}
Public  void m4(){}
}
Class  C  extends  B{
Public void m1(){
System.out.println(“l  just want to use the m 1() , hehe ! ”);
}
}

\
话题九：Object 类（所有的类的默认父类）
一：超类中一些方法及其使用
1：Equals ();
（1）：用来判断两个对象是否相等（只有类类型的对象有这个方法）
对于字符串类型：
Equals (): 指的是两个对象的内容是否相同
“==”：指的是两个对象是否是一个对象（内存地址空间相同）。
对于普通的对象：默认情况下都指是否是同一个对象。通常需要重写equals （）。
public class EqualsTest {
public static void main(String[] args) {
String s1="hello";
String s2=new String("hello");
String s3=s1;
System.out.println("验证字符串");
System.out.println(s1==s2);
System.out.println(s1.equals(s2));

System.out.println(s1==s3);
System.out.println(s1.equals(s3));

System.out.println("验证普通的类");
A a =new A(5,"xuzheng",5);
A b =new A(5,"xuzheng",5);
A c=a;
System.out.println(a==b);
System.out.println(a.equals(b));
System.out.println(a==c);
System.out.println(a.equals(c));
}
}
2：toString();可以看作是对类类型的变量进行输出运算符重载
3：hashcode();在重写equals()方法的时候，需要重写hashcode()方法，来保证相同的对象有相同的hashcode;
4：clone();
注意：能够进行克隆的对象一定要实现cloneable接口，实现里面的clone() 方法。否则会抛出：CloneNotSupporttedException;
默认情况下是浅拷贝：把基本类型进行复制，引用类型把地址值进行复制：
深拷贝：需要把引用类型所指向的内容也进行原样复制，而不仅仅是地质的拷贝。
Car car = (Car) super.clone();//只完成了对car对象内存空间的复制
car.cd = (CD) car.getCd().clone();//再完成对引用类型的对象的拷贝

话题二：内部类
1：静态内部类：
（1）静态内部类可以用可见修饰副修饰
（2）静态内部类中可以定义静态或者非静态的成员
（3）静态内部类只能够访问外部类的静态成员。
（4）外部类访问内部类的静态成员，访问方式为：Inner.staticMember;
如果外部类访问内部类的非静态成员,就需要实例化内部类实例。
2：成员内部类
成员内部类中不能够定义静态的成员
在成员内部类中可以访问外部类的所有成员。
外部类访问成员内部类成员的时候，需要先实例化一个内部类对象。
外部类的静态成员不能都访问成员内部类。如果需要使用分三步走
构造外部类的实例
构造内部类的实例，outer.new inner()
3：方法内部类：（不要求，很少使用）
（１）：定义方法内部类的时候不能加修饰符。
（２）：方法内部类中的方法只能访问所在方法的常量
（３）：外部类需要调用方法内部类的一个方法，需要在内部类所在的方法通过new 语句调用内部类的构造器，在构造器里面调用内部类的方法，（很少使用）
4：匿名内部类
书写格式：
New className{
方法实现；
}
可以简化编程，但是这个对象只能使用一次：
注意：类名可以是一个接口的名字。
5：内部类的优点：
（1）：保持更好的封装性
（2）：多重继承
（3）：可以方便的访问外部类的成员

话题十：集合
１：作用和定义：　用来管理对象的容器对象，也可以叫做集合。每一个元素里面装的本质上是一个对象的地址：
2：集合的遍历：
跌代器（Iterator及其子接口ListIterator）：用于操作容器中对象的一种特殊的对象，他由容器自己提供。
注意：它只是依附于某一个集合对象的一个遍历工具。
（2）二者的区别：
iterator: 只能从前往后遍历
Listiterator:可以任意方向的遍历
注意：map 不属于collection.
（３）书写格式：
Collection c=new Collection();
Iterator  it=c.iterator();
二：管理单个对象容器分类

2 楼 meohao 2010-08-28  

四：Final
1：修饰范围：修饰属性，方法和类
2：模板方法模式：
目的：父类中定义抽象的基本方法和final的模板方法，由子类负责实现基本方法，但是无权修改模板方法。（各司其职）
3：final 修饰的属性不能被更改
◆如果修饰的是实例变量，那么可以在声明或者是在构造方法里面或者在动态初始化代码块里面初始化，要保证在对象创建完之后，这个值已经确定下来了，三者只能选择其一，一旦确定下来就不能再更改。
例如：
Class  A{
private static int a=10;  //生明的时候直接给值
Public A{ a=20; } //构造的时候给值
{a=20；}    //初始化代码块给值
}
◆如果修饰的是类变量（final 和static 同时出现），那么要在声明的时候，或者在静态初始化块里面赋值。必须保证在类加载之后，就已经有了一个确定的值。
注意：都不能进行两次不同的赋值，但是可以进行操作。
4：final 修饰的方法不能被覆盖
5：final 修饰的类不能被继承(不能与abstract混用)

五．abstract ：
1：修饰范围：类和方法
2：Abstract 修饰的方法叫做抽象方法，只定义，没有实现。
例如：Public  abstract  void m();
　　跟C++ 中的虚函数相似
3：修饰的类叫做抽象类，抽象类不能实例化 。
　　Abstract class A{}　　
　Ａａ＝new  A();//不允许的
注意：abstract 和final，static ，private 中的任何一个不能够同时修饰
如果一个类中有抽象方法，那么一定是抽象类，但是抽象类中不一定有抽象方法
抽象类也有构造方法
抽象类中可以有静态的方法（特例：主方法main()）

话题七．模版方法编程 ：
1：使用原因：
现实例子：
一个制作瓷器的工艺流程的顺序是固定（先拌泥，再塑形状，最后烧制），但是不同的人在完成每一个步骤的具体操作是不一样的。
代码：
public class Process {
//模版方法来固定操作流程,并且用final修饰，任何一个类不能再作修改。
public final void 制陶瓷(){
拌泥();  
塑型();
烧制();
}
public void 拌泥(){ }
public void 塑型(){ }
public void 烧制(){ }
}
//第一个人的实现方式
public class Person1 extends Process{
public void 拌泥(){
System.out.println("我用红泥拌");
}
public void 塑型(){
System.out.println("我用双手塑型");
}
public void 烧制(){
System.out.println("我用土窑烧制");
}
}
//第二个人的实现方式
public class Person2 extends Process {
public void 拌泥(){
System.out.println("我用黑泥拌");
}
public void 塑型(){
System.out.println("我用塑料模型塑型");
}
public void 烧制(){
System.out.println("我用炼丹炉烧制");
}
}
public class TestTemplate {
public static void main(String[] args) {
Process p1=new Person1();
Process p2=new Person2();
p1.制陶瓷();
System.out.println("=============");
p2.制陶瓷();
}
}


话题八：接口

1: 定义：
（1）本质上是一个抽象类；
（2）接口里面的方法都是公开抽象方法；(自动的是public abstract)
（3）所有的属性一定要赋值，并且自动都是public static final 修饰的静态常量；（public static final不用显式的写）
（4）没有构造方法；
例子：
Interface A{
Public static final int a=20; //必须是一个静态常量
Public void m();   //必须是一个抽象方法
}
Class C implements A{}
2: 类和接口的关系
（１）：实现关系。（类实现接口的抽象方法，简称为类实现接口）　　　（２）：逻辑上的父子关系（逻辑上相当于接口是实现类的父类）
如果不希望实现类是抽象类，那么就要实现接口中定义的所有的方法。
接口不能构造对象， 但是可以作为引用类型（编译时类型），只能调用接口中定义的方法，运行时找接口实现类中实现的方法，
接口对象其实是接口实现类的对象
例子：Interface A{
Public static final int a=20;//必须是
Public void m();
}
Class C　 implements　 A{
Public void m(){
System.out.println(“C  实现了 A ”);
}
}
Public class Test{
Public  Static  void main(String []args){
A  a =new C ();
a.m();       //打印的是C  实现了 A
}
}
（３）：一个类只能继承父类，但是可以实现多个接口
（可以联想一个人只能有一个亲爹，但是可以有多个干爹，但是作为父类来说，不管是亲儿子还是干儿子都是儿子）
（４）：一个接口可以继承多个接口。
３：使用接口的优势：
（1）：可以实现多继承，并且不会破坏类之间的树状关系，（多继承网状）接口是对类关系的补充，是一种附加的信息，不会影响类的主干继承关系。
区分类的主类型（亲爹）和副类型（干爹）。
（2）：弱耦合的工具
把制定标准，使用标准和实现标准三者分开，这样实现者和使用者之间的耦合度就降低了。（使用者只要知道指定的标准就OK了）
针对接口编程思想：
程序中所有的引用类型，包括局部变量，方法的参数，方法的返回类型，都尽量使用接口。
4：标示接口
（１）：定义：没有任何方法的空的接口，
（２）：作用：用来标示类型
5：接口与抽象类的区别
抽象类可以有部分的实现，但是接口里面必须全部是抽象方法。
抽象类可以有构造方法，但是接口不可以有构造方法。
抽象类里面可以有非静态常量，但是接口里面必须是静态常量，
并且不能是私有的（如果是私有的，这个常量已经不具备任何作　　用，其他地方不可见，自己又没有使用）

1 楼 meohao 2010-08-28  

×     Dog d=new Animal();

2：两种类型
◆编译时类型：主观拟定的类型，（当作父类型看）
◆运行时类型：客观上的类型（实际的子类型，只能往上跃升）
3：特点：
◆对象不变（客观存在不变。）
◆如果实现了对多态，那么在进行函数调用的时候只把这个对象当作父类看待。不能调用子类所特有的方法。
◆运行时会根据对象的实际类型（运行时类型）找覆盖之后的方法

        话题六：  关键字的使用
一：This ;
1：作用：指的是当前对象
2：使用范围：
◆在构造方法中，用this 调用这个类的另外的构造方法。
      ◆用来区分局部变量和实例变量；(最常用的)
二：Super：
1：作用：用来指父类对象
2：使用范围：
◆在一个构造方法中，如果没有明确的使用this 或者super关键字，那么系统会自动在第一行加上super（），调用父类无参的构造方法（这个要求也是一个类中必须要有一个无参的构造方法的原因）
◆通过super 来调用父类的公开方法。
◆在构造函数里面，只能放在第一行来显式的调用父类相应的构造方法，


三：Static :
1：修饰范围： 修饰变量，方法和初始化代码块
2：类加载：字节码文件----〉内存，只加载一次。
（1）原则：能不加载就不加载 ，
本质：如果在实例化之前必须要确定类类型，就必须要加载。
（2）加载的时机：
◆第一次new 对象的时候
Animal a=new Animal ()　 //加载
Animal a=null;//不加载，
在别的文件里，第一次访问类static 成员
  Class.chengyuan;
成员需要用类名调用，就必须知道类的类型
在别的文件里面，声明一个引用的时候不会加载
Class A{
ClassC  c=null ;//只用给它留一个可以装的下一个地址的空间。
}
A  a =new A();
◆如果需要加载子类，必须先要加载父类
   创建子类之前先要创建一个父类
◆如果通过子类访问父类的方法，那么只需要加载父类
因为在加载的时候是先加载父类再加载子类，加载完父类之后就已经找到了这个方法，
◆如果访问的是类的公开静态常量，是否加载要看这个常量是什  么时候的常量
如果编译的时候，编译器已经知道了这个常量的值，那么就不需要加在这个类，如果只有在运行的时候才能确定这个常量，那么就需要加载这个类。
3．单例模式：
（1）定义：在整个程序的运行过程之中，这个类的实例只有一个，即只有一个这种类型的对象；
（2）实现手段：
◆将构造函数置为私有的，不让通过new 来新生成一个对象；
◆提供一个取得这个类实例的工厂方法，如果这个对象已经有了一个实例（对象），那么只给使用这个已经存在的对象，否则才给创建一个新的实例对象。
（３）例子：
现实例子：一个人在商店购物的整个过程中，多次把商品放在购物车里，但是每一次都是往同一个购物车里面放东西。
代码实现：
public class ShoppingCart{
private static ShoppingCart  s;
private static int number=0;
private ShoppingCart (){   //将构造方法私有
number++; //用来验证构造对象的个数。
System.out.println(number);
}
//对外可以获得本类对象的唯一通道
public static ShoppingCart getSingle(){ if(s==null)
s=new ShoppingCart ();
return s;
}
}
public class Shopping {
public static void main(String[] args) {
//第一次获得对象的时候，因为没有对象存在，所以要getsingle()方法要调用构造函数，创建一个对象
ShoppingCart s= ShoppingCart.getSingle();
//输出Number=1；
//第二次获得对象的时候，已经有了一个实例，那么系统就不会再创建对象，直接用已经有的对象。
ShoppingCart s2= ShoppingCart.getSingle();
//没有输出，说明没有调用构造函数。
}
}
4：static 修饰的变量（类变量）
所有的类共有一份，在类实例化之前就已经存在了。可以直接用类名进行访问。
例子：给信用帐户设置id
5：static 修饰方法
特点：
◆在实例化对象之前就可以通过类名直接调用
◆静态方法不能访问非静态属性或者非静态方法，但是非静态方法可以访问静态方法
◆静态方法可以被覆盖，但是覆盖的修饰符号必须一致；父static 子static ，父非static 子非static ，没有什么意义。（即使覆盖了，也不能实现多态）
例子：
public class Father{
public static void show(){
System.out.println("father");
}
}
public class Son extends Father{
public static void show(){
System.out.println("son");
}
}
public class Test {
public static void main(String[] args) {
Father f=new Son();
f.show();
}
}
6: static 修饰的静态代码块
（1）动态初始化代码块：{}在每一次调用构造函数之前初始化属性的时候调用
（2）静态初始化代码块：static {}在加载类对象的时候调用，只调用一次。
注意：本质上也是一个静态方法，也只能访问类的静态成员。