java学习笔记

[url]http://www.runoob.com/java/java-stringbuffer.html[/url]
局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。 访问修饰符不能用于局部变量

成员变量(实例变量)：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息

类变量（静态变量）：类变量也声明在类中，方法体之外，但必须声明为static类型。；
构造方法:在创建一个对象的时候，至少要调用一个构造方法。
类变量被声明为public static final类型时，类变量名称必须使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。

源文件声明规则:一个源文件中只能有一个public类
一个源文件可以有多个非public类
java中4中修饰符分别为public、protect、default、private，


访问控制修饰符
默认的，也称为default，在同一包内可见，不使用任何修饰符。
私有的，以private修饰符指定，在同一类内可见。声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问。并且类和接口不能声明为private。
共有的，以public修饰符指定，对所有类可见。
受保护的，以protected修饰符指定，对同一包内的类和所有子类可见。

继承规则：父类中声明为public的方法在子类中也必须为public。
父类中声明为protected的方法在子类中要么声明为protected，要么声明为public。不能声明为private
父类中声明为private的方法，不能够被继承。

Final修饰符：
Final变量能被显式地初始化并且只能初始化一次。被声明为final的对象的引用不能指向不同的对象。但是final对象里的数据可以被改变。也就是说final对象的引用不能改变，但是里面的值可以改变。
类中的Final方法可以被子类继承，但是不能被子类修改。
声明final方法的主要目的是防止该方法的内容被修改。


final 类不能继承
final 方法不能重新override，可以继承
final 成员变量可以继承


Java语言中提供的数组是用来存储固定大小的同类型元素。

Static修饰符
静态变量：
Static关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被成为类变量。局部变量能被声明为static变量。
静态方法：
Static关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

--------------------------------------------------------------
java捕获与非捕获：[url]http://www.360doc.com/content/12/0123/05/820209_181153675.shtml[/url]

-------------------------------------------------------------------------
java 定义map：
Map<String,String> mymap=new HashMap<String,String>();
mymap.put("string1","string2");


构造方法:构造方法和它所在类的名字相同，但构造方法没有返回值。

在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类
extends和implements
classB继承classA，如果classA类中的变量设置成private，则classA无法访问该变量
----------------------------------------------------------------------

抽象类除了不能实例化对象之外，类的其它功能依然存在，由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用
抽象类

public abstract class AbstractClass             //里面至少有一个抽象方法
{ 
     public abstract void method1();   //抽象方法，抽象类的子类在类中必须实现抽象类中的抽象方法
}

声明抽象方法会造成以下两个结果：
如果一个类包含抽象方法，那么该类必须是抽象类。
任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
————————————————————————————————————————java接口：
在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口与类相似点：
一个接口可以有多个方法。
接口文件保存在.java结尾的文件中，文件名使用接口名。
接口的字节码文件保存在.class结尾的文件中。
接口相应的字节码文件必须在与包名称相匹配的目录结构中。
接口与类的区别：
接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了static和final变量。（成员变量要被实例化对象才可以用 ，而接口不能被实例化）
接口不是被类继承了，而是要被类实现。
接口支持多重继承。
接口中的方法都是公有的。
一个接口能继承另一个接口，和类之间的继承方式较相似。接口的继承使用extends关键字
在Java中，类的多重继承是不合法，但接口允许多重继承，。
没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：
建立一个公共的父接口：向一个类添加数据类型：
接口（interface）的定义方式如下：

public interface Interface
{ 
 　　static final int i;  //接口中不能有普通数据成员，只能够有静态的不能被修改的数据成员,static表示全局，final表示不可修改，可以不用static final 修饰，会隐式的声明为static和final
　　 public void method1();  //接口中的方法一定是抽象方法，所以不用abstract修饰
}

----------------------------------------------------------
方法的重写规则：
参数列表必须完全与被重写方法的相同；//父类中有的方法，子类才可以重新写，父类中没有的方法，子类不能重新写。
返回类型必须完全与被重写方法的返回类型相同；
声明为final的方法不能被重写
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。（可以重写static方法）
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。
访问权限不能比父类中被重写的方法的访问权限更高。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

Super关键字的使用：当需要在子类中调用父类的被重写方法时，要使用super关键字。
------------------------------------------------------------------------------
重载(Overload)：
被重载的方法必须改变参数列表；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载
也就是子类能够重载父类的方法。
当子类对象调用重载的方法时，调用的是子类的方法，而不是父类中被重载的方法。
要想调用父类中被重载的方法，则必须使用关键字super。

java多态：
引用型变量：

public interface Vegetarian{}
public class Animal{}
public class Deer extends Animal implements Vegetarian{}

Deer d = new Deer();
Animal a = d;
Vegetarian v = d;
Object o = d;

--------------------------------------------------------------------------
java封装：（把类中的变量设置成private类型，外部类要访问该变量通过getter和setter方法。）

-------------------------------------------------------------------------

java迭代器：
迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。
　　Java中的Iterator功能比较简单，并且只能单向移动：
　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。
　　(2) 使用next()获得序列中的下一个元素。
　　(3) 使用hasNext()检查序列中是否还有元素。
　　(4) 使用remove()将迭代器新返回的元素删除。
　　Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。
迭代器应用：

 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }

/*迭代器用于while循环

Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }

*/
-------------------------------------------------------------------------------
[url]http://www.cnblogs.com/rollenholt/archive/2011/09/02/2163758.html[/url]
[url]http://www.douban.com/note/306848299/[/url]
java反射：
1、Java反射的概念
　　反射含义：可以获取正在运行的Java对象。
2、Java反射的功能
　　1)可以判断运行时对象所属的类
　　2)可以判断运行时对象所具有的成员变量和方法
　　3)通过反射甚至可以调用到private的方法
　　4)生成动态代理

通过一个对象获取完整的包名和类名
demo.getClass().getName() //demo是class Demo的一个实例

package zouhuiying
//获取指定的包名
三种实例化class的方法

Class<?> demo1=null;  //定义demo1是个class，但是不知道具体的类。
1.demo1=Class.forName("zouhuiying.Demo").getName();
2.demo2=new Demo().getclass.getName();
3.demo3=Demo.class.getName()
zouhuiying.Demo
getclass得到的是class对象。getName得到的是class的名字

//获取类的修饰符

demo3=Demo.class （对象）
demo3=new Test().getClass();
int mod=demo3.getModifiers();
String modifier = Modifier.toString(mod);
System.out.println(demo3+" demo3");
System.out.println("modifier = " + modifier);

//获取指定类的父类
　

　Class superClazz = demo3.getSuperclass();
　　String superClazzName = superClazz.getName();
　　System.out.println("superClazzName = " + superClazzName);

-------------------------------------------------------------------------
控制反转：[url]http://www.bubuko.com/infodetail-828928.html [/url]
注射控制器类BeanFactory
传统模式中是类和类之间直接调用，所以有很强的耦合度，程序之间的依赖关系比较强，后期维护时牵扯的比较多。
IOC，用配置文件(XML)来描述类与类之间的关系，由容器来管理，降低了程序间的耦合度，程序的修改可以通过简单的配置文件修改来实现