1.Java基础概念
Path：windows系
统那个执行命令时要搜寻的路径。
classpath：java在编译和运行时要找的class所在的路径。
一个源文件中最多只能有一个public类，其他类的个数不限。
//用于单行注释
/* */用于多行注释
/** */用于多行注释，且可以被doc工具解析
java标识符命名规则
1.标识符由字母、下划线"_"、美元符"$"或数字组成。
2.标识符应该以字母、下划线、美元符开头。
3.Java标识符大小写敏感，长度无限制。
Java内存管理分为四个区域：heap、stack、code segment、data segment
stack ：局部变量
heap： 所有 new 出来的东西
code segment：存放代码
data segment：静态变量，字符串常量
注意：类是静态的概念，存在于code segment中；对象是动态的概念，因为时new出来的，所以位于heap中。
面向对象的设计思想是：从现实世界中客观存在的事物出发来构造软件系统，并且系统的构造中尽可能运用人类的自然思维方式。
方法的重载(overload)
一个类可以有相同的名字，但参数不同的多个方法。调用时，会根据不同的参数来选择对应的方法。
构造方法也可以重载。
this关键字的说明
1.在类的方法定义中使用的this关键字代表使用该方法的对象的引用。
2.当必须指出当前使用方法的对象是谁的时候要是用this。
3.有时使用this可以处理的方法中成员变量和参数重名的情况
4.this可以看作是一个变量，它的值是当前对象的引用。
static关键字的说明
1.在类中，使用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用那个是被初始化，对于该类的所有对象来说，static成员变量只有一份。
2.用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。静态方法不再是针对某个对象调用，所以不能访问非静态成员。
3.可以通过对象引用或类名(不需要实例化)访问静态成员。
J2SDK中主要的包介绍
1.java.lang----包含一些java的核心类，如String、Math、Integer、System和Thread，提供常用的功能。
2.java.awt----包含了构成抽象窗口工具集(abstract window toolkits)的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)
3.java.applet----包含applet运行所需的一些类。
4.java.net----包含执行与网络有关的操作的类。
5.java.io----包含能提供多种输入/输出功能的类。
6.java.util----包含一些使用工具类，如定义系统特性、使用与日期日历相关的函数。
打jar包命令：jar -cvf xxxx.jar *.*
访问控制
1.Java权限修饰符 public、protected、private置于类的成员定义前，用来限定其他对象对该类对象成员的访问权限。
2.对于class的权限修饰只可以用public和default.
3.public 类可以在任何地方被访问。
4.default类之可以被统一个包内部的类访问。
方法的重写(overwrite/override)
1.在子类中可以根据需要对从基类中继承来的方法进行重写。
2.重写方法必须和被重写的方法具有相同的名称、参数列表和返回类型。
3.重写方法不能使用比被重写的方法更严格的访问权限。
继承中的构造方法
1.子类的构造的过程中必须调用其基类的构造方法。
2.子类可以在自己的构造方法中使用super(argument_list)调用基类的构造方法。
(1)使用this(argument_list)调用本类的另外的构造方法。
(2)如果调用super，必须写在子类构造方法的第一行。
3.如果子类的构造方法中没有显示地调用基类的构造方法，则系统默认调用基类无参的构造方法。
4.如果子类构造方法中既没有显示调用基类构造方法，而基类中有没有无参的构造方法，则编译出错。
Object类的说明
Object类是所有Java类的根基类。如果在类的声明中未使用extends关键字指明其基类，则默认基类为 Object类。
toString方法
1.Object类中定义有public String toString()方法，其返回值是String类型，描述当前对象的有关信息。
2.在进行String与其它类型数据的连接操作时，(如：System.out.println("info" +people))，将自动调用该对象的toString()方法。
3.可以根据需要在用户自定义类型中重写toString()方法。
equals方法
1.Object类中定义有：public boolean equals(Object obj)方法
2.Object的equals方法定义为：x.euqals(y)，当x和y是统一个对象的应用的时候返回ture，否则反回false。
3.J2SDK提供的一些类，如String、Date等，重写了Object的equals方法，调用这些内容的equals方法，x.equals(y)，当x和y所引用的对象是同一类对象且属性内容相等时(并不一定是相同的对象)，返回true，否则返回false。
4.可以根据需要在用户自定义的类型中重写equals方法。
对象转型(casting)
1.一个基类的引用类型可以"指向"其子类的对象。
2.一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)。
3.可以使用引用 变量 instanceof 类名 来判断该引用变量所 "指向"的对象是否属于该类或该类的子类。
4.子类的对象可以当作基类的对象来使用 称为向上转型 (upcasting)，反之称为向下转型(downcasting)
多态
1.要有继承
2.要有重写
3.父类引用指向子类对象。
抽象类
1.用abstract关键字来修饰一个类时，这个类叫抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。
2.含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。
3.抽象类不能被实例化。
4.抽象方法只需声明，而不需实现。
abstract class Person {
private String name;
Person(String name) {
this.name = name;
}
public abstract void study(); //抽象方法只能被声明
}
final关键字(相当于C++中的const)
1.final的变量的值不能被改写。
2.final的方法不能被重写
3.final的类不能被继承。
接口
1.接口是抽象方法和常量值的定义的集合。
2.从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
3.接口的特性
1.多个无关的类可以实现同一个接口。
2.一个类可以实现多个无关的接口。
3.与继承关系类似，接口与实现类之间存在多态性。
4.接口中声明 属性 默认为public static final的，也只能是public static final的
5.接口只能定义 抽象方法，而且这些 方法 默认为public的，也只能是public的
6.接口可以继承其他的借口，并添加新的属性和抽象方法。
2.关于包与File的一点注意
就是说生成了一个File类对象，而这个程序使用了包 com.xxx.www，那么这个文件的真实根路径就是最外层
包com所在的路径。也就是说这个程序编译后要想运行，使用如下命令java com.xxx.www.程序名称（也就
是：java 包名.程序名称），但是生成的file却在com所在的父路径下。
3.容器综述
Set 中的数据对象没有顺序且不可以重复。
List 中的数据对象有顺序且可以重复。
Map 接口定义了存储"键(key)-值(value)"映射对的方法。
Collection、Set、List、Map为接口。
注意：所谓的重复是指两个对象equals()；需要进入java.util.*包
Collection举例
********************************************************************************************
1.容器类对象在调用remove、contains等方法时需要比较对象是否相等，这会涉及到对象类型的equals方法 *
和hashCode方法；对于自定义的类型，需要重写equals和hashCode方法以实现自定义的对象相等规则。 *
2.相等的对象应该具有相等的hash codes 。 *
********************************************************************************************
import java.util.*;
public class BasicContainer {
public static void main(String[] args) {
Collection c = new HashSet();
c.add("hello");
c.add(new Name("f1","l1"));
c.add(new Integer(100)); //String类重写了equals()方法，所以会去除100
c.remove("hello"); //String类重写了equals()方法，所以会去除"hello"
c.remove(new Integer(100));
System.out.println
(c.remove(new Name("f1","l1"))); //自己定义的类，要想返回true，必须重写equals()方法。
System.out.println(c);
}
}
class Name {
private String firstName,lastName;
public Name(String firstName, String lastName) {
this.firstName = firstName; this.lastName = lastName;
}
public String getFirstName() { return firstName; }
public String getLastName() { return lastName; }
public String toString() { return firstName + " " + lastName; }
public boolean equals(Object obj) {
if (obj instanceof Name) {
Name name = (Name) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj); //如果自己处理不了，就交给父类Object去处理。
}
public int hashCode() {
return firstName.hashCode(); //交给了String的hashCode()方法去处理
}
}
Iterator接口
1.所有实现了Collection接口的容器类都有一个iterator方法用以返回一个实现了Iterator接口的对象。
2.Iterator对象称为迭代器，用于方便的实现对容器内元素的遍历操作。
3.Iterator接口定义了如下方法：boolean hasNext() //判断游标右边是否有元素
Object next() //返回游标右边的元素并将游标移动到下一个位置
void remove() //删除游标左边的元素，在执行完next之后该操作只
能执行一次。
举例1：
Collection c = new HashSet();
c.add(new Name("f2","12"));
c.add(new Name("fff3","1113"));
for(Iterator i = c.iterator(); i.hasNext(); ) {
Name name = (name) i.next();
if(name.getFirstName().length() < 3) {
i.remove();
}
}
System.out.println(c);
说明：这个程序里，虽然Collection也有remove方法，但是不能c.remove(name)，这样会出错。
因为执行这个程序是，iterator执行了锁定。
增强的For循环 (J2SDK 1.5以后增加的)
import java.util.*;
public class EnhancedFor {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5};
for(int i : arr) { //将arr中的元素依次拷贝到i中，然后打印i。
System.out.println(i);
}
Collection c = new ArrayList();
c.add(new String("aaa"));
c.add(new String("bbb"));
c.add(new String("ccc"));
for(Object o : c) {
System.out.println(o); //将c中的元素依次拷贝到o中，然后依次打印o。
} //这里的println是调用了o的toString方法，因为String类重写了toString方法
} //了，所以这里就调用了String类的toString方法，这里面存在多态。
}
优点：对于遍历Array或Collection的时候相当方便。
缺点：遍历数组的时候不能访问下标。
与使用iterator相比，不能方便的删除集合中的内容。在内部也是调用iterator。
总结：除了简单遍历并读出其中的内容外，不建议使用增强的for。
List常用算法
类java.util.Collections提供了一些静态方法实现了基于List容器的一些常用算法。
1.static void sort(List) 对List容器内的关系排序。
2.static void shuffle(List) 对List容器内的对象进行随机排序。
3.static void reverse(List) 对List 容器内的对象进行逆序排列。
4.static void fill(List, Object) 用一个特定的对象重写整个List容器。
5.static void copy(List dest, List src) 将src List容器内的内容拷贝到dest List容器内。
6.static int binarySearch(List, Object) 对于顺序的List容器，采用折半查找的方法找特定的对象。
Comparable接口
1.问题：上面的算法根据什么确定容器中的对象的"大小"顺序？
2.所以可以"排序"的类都实现了java.lang.Comparable接口，Comparable接口中只有一个方法
public int compareTo(object obj)
该方法的返回值为：0 表示this==obj
正数表示this > obj
负数表示this < obj
4.实现了Comparable接口的类通过实现compareTo方法从而确定了该类的排序方式。
例子：
import java.util.*;
public class BasicContainer {
public static void main(String[] args) {
Collection c = new HashSet();
c.add("hello");
c.add(new Name("f1","l1"));
c.add(new Integer(100));
c.remove("hello");
c.remove(new Integer(100));
System.out.println
(c.remove(new Name("f1","l1")));
System.out.println(c);
//下面的一段代码是应用comparable的例子
List l = new LinkedList();
l.add(new Name("Karl","L"));
l.add(new Name("Steven","Lee"));
l.add(new Name("Tom","Wang"));
System.out.println(l);
Collections.sort(l); //调用了Name的compareTo方法
System.out.println(l);
}
}
class Name implements Comparable {
private String firstName,lastName;
public Name(String firstName, String lastName) {
this.firstName = firstName; this.lastName = lastName;
}
public String getFirstName() { return firstName; }
public String getLastName() { return lastName; }
public String toString() { return firstName + " " + lastName; }
public boolean equals(Object obj) {
if (obj instanceof Name) {
Name name = (Name) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj);
}
public int hashCode() {
return firstName.hashCode();
}
public int compareTo(Object o) {
Name n = (Name)o;
int lastCmp =
lastName.compareTo(n.lastName); //调用了String类的compareTo方法，因为String类重写了该方法
return
(lastCmp!=0 ? lastCmp :
firstName.compareTo(n.firstName));
}
}
Array 读快改慢
Linkded改快读慢
Hash 两者之间
Map接口
1.实现Map接口的类用来存储键-值对
2.Map接口的实现类有HashMap和TreeMap等。
3.Map类中存储的键-值对通过键来标识，所以键值不能重复(必须重写equals方法和hashCode方法，才能保证不能重复)
自动打包/自动解包
看下面的例子
import java.util.*;
public class TestMap {
public static void main(String args[]) {
Map m1 = new HashMap();
Map m2 = new TreeMap();
//m1.put("one",new Integer(1));
m1.put("one", 1); //自动将int 大包成 Integer类型
//m1.put("two",new Integer(2));
m1.put("two", 2);
//m1.put("three",new Integer(3));
m1.put("three", 3);
//m2.put("A",new Integer(1));
m2.put("A", 1);
//m2.put("B",new Integer(2));
m2.put("B", 2);
System.out.println(m1.size());
System.out.println(m1.containsKey("one"));
System.out.println
//(m2.containsValue(new Integer(1)));
(m2.containsValue(1));
if(m1.containsKey("two")) {
//int i = ((Integer)m1.get("two")).intValue();
int i = (Integer)m1.get("two"); //自动将Integer 解包成 int类型
System.out.println(i);
}
Map m3 = new HashMap(m1);
m3.putAll(m2);
System.out.println(m3);
}
}
例子2
import java.util.*; //没有自动打包/解包
public class TestArgsWords {
//private static final Integer ONE = new Integer(1);
private static final int ONE = 1;
public static void main(String args[]) {
Map m = new HashMap();
for (int i = 0; i < args.length; i++) {
Integer freq = (Integer) m.get(args[i]);
m.put(args[i],(freq == null? ONE : new Integer(freq.intValue() + 1)));
}
System.out.println
(m.size() + " distinct words detected:");
System.out.println(m);
}
}
import java.util.*; //修改后的程序，使用了自动打包/解包
public class TestArgsWords {
//private static final Integer ONE = new Integer(1);
private static final int ONE = 1;
public static void main(String args[]) {
Map m = new HashMap();
for (int i = 0; i < args.length; i++) {
int freq = (Integer) m.get(args[i]) == null ? 0 : (Integer) m.get(args[i]);
m.put(args[i], freq==0 ? ONE : freq + 1);
}
System.out.println
(m.size() + " distinct words detected:");
System.out.println(m);
}
}
每天都有新的变化，请关注我的Blog