一 4类8种基本数据类型
逻辑型 - boolean
文本型 - char
整数型 - byte short int long
浮点数型 - float double
☆java各整数类型有固定的表数范围和字段长度，其不受具体操作系统的影响以保证java程序的可移植性。
☆java 语言的整型常量默认为int型，声明long型常量后可以加‘l’或‘L’.
☆java浮点类型常量默认为double型，如要声明一个常量用float型，则要在数字后面加f或F.
基本数据类型转换
☆ boolean 类型不可以转换为其他的数据类型。
☆ 容量小的类型自动韩国的为容量大的数据类型;大小排序为：
byte short char ->int -> long ->float ->double.
Byte short char之间不能互相转换。
☆有多种数据混合运算时，会自动转换成最大的数据类型再进行计算。
容量大的数据类型韩国的为容量小的数据类型时，要加上强制转换符。
字符串连接
☆“+”运算符两侧的操作数中只要有一个是字符串（String）类型，系统会自动将另一个操作数转换为字符串后再进行连接。
☆ 当进行打印时，无论任何娄类型，都自动转为字符串进行打印。
★局部变量要初始化才能使用。成员变量不初始化也能使用。因为成员变量系统会自己赋默认的值。
★new出来的东西都在堆里。
约定俗成的命名规则
◇类名的首字母大写
◇变量名和方法名的首字母小写
◇运用驼峰标识
二、标识符命名规则
a 标识符只能由字母、数字、下划线 “_” 和 美元符号“$ ”或者人民币符号“￥”组成
b数字不能开头，即标识符的第一个字母必须是字母或下划线，不能是数字。
c不能把关键字和保留字作为标识符。
d标识符的要有一定的意义。
e标识符严格区分大小写。
f标识符没有长度限制，但应当符合“min-length && max-information”原则。
方法（C++中叫函数）
☆Java语言中使用下述形式调用方法： 对象名.方法名（实参列表）。
☆实参的数目、数据类型和次序必须和所调用方法声明的形参列表匹配。
☆传递参数时，遵循值传递的原则：基本类型传递的是该数据值本身。引用类型传递的是对对象的引用。而不是对象本身。
构造方法（构造函数）
◇使用new+构造方法创建一个新的对象
◇构造函数是定义在java娄中的一个用来初始化对象的函数。
◇构造函数与类同名且没有返回值。
◇不能在前面加void
◇没有指定构造函数时，编译器会自动添加。指定后就不会自动添加，会报错。
四 程序执行过程：
三、final
根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
1、final类
final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
2、final方法
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法
使用final方法的原因有二：
a 把方法锁定，防止任何继承类修改它的意义和实现。
b高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
3、final变量（常量）
用final修饰的成员变量表示常量，值一旦给定就无法改变！
final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
一旦给final变量初值后，值就不能再改变了。
另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数
中。这两个地方只能选其一。
4、final参数
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
方法的重载
◇方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时，用根据不同的参数表选择对应的方法。
◇构造方法也可以重载。
★重载方法满足以下条件
☆方法名相同。
☆方法的参数类型，个数，顺序至少有一项不相同。
☆方法的返回类型可以不相同。
☆方法的修饰符可以不相同。
★在一个类中不允许定义另个方法名相同，并且参数签名也完全相同的方法。假如存在这样的两个方法，Java 虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型，个数和顺序。
覆盖方法
如果在子类中定义的一个方法，其名称，返回类型及参数签名正好与父类中某个方法的名称，返回类型及参数签名相匹配，那么可以说，子类的方法覆盖了父类的方法。
★覆盖方法必须满足多种约束
1）子类方法的名称，参数签名和返回类型必须与父类方法的名称，参数签名和返回类型一致
2) 子类方法不能缩小父类方法的访问权限。
3）子类方法不能抛出比父类方法更多的异常。
4）方法覆盖只存在于子类和父类（包括直接父类和间接父类）之间，在同一个类中方法只能被重载，不能被覆盖。
this关键字
在类的访求定义中使用的this关键字代表使用该方法的对象引用。
当必须指定当前使用方法的对象是谁时要使用this。
this可以看作是一个变量，它的值是当前对象的引用。
◇1、我们想通过构造方法将外部传入的参数赋值给类的成员变量，构造方法的形式参数名称与类的成员变量名相同。如：
class Person
{
String name;
public Person(String name)
{
this.name = name;
}
}
◇2、假设有一个容器类和一个部件类，在容器类的某个方法中要创建部件类的实例对象，而部件类的构造方法要接受一个代表其所在容器的参数。如
class Container
{
Component comp;
public void addComponent()
{
comp = new Component(this);
}
}
class Component
{
Container myContainer;
public Component(Container c)
{
myContainer = c;
}
}
◇3、构造方法是在产生对象时被java系统自动调用的，我们不能再程序中像调用其他方法一样去调用构造方法。但我们可以在一个构造方法里调用其他重载的构造方法，不是用构造方法名，而是用this（参数列表）的形式，根据其中的参数列表，选择相应的构造方法。
public class Person
{
String name;
int age;
public Person(String name)
{
this.name = name;
}
public Person(String name,int age)
{
this(name);
this.age = age;
}
}
◇3、在一个构造函数中调用另一个构造函数时，用this关键字
public class Flower{
private int petalCount=0;
private String s=new String("null");
public Flower(int petals){
petalCount=petals;
}
public Flower(String ss){
s=ss;
}
public Flower(String s,int petals){
this(petals); //java中在一个构造函数中可以调用一次其他的构造函数，并且这条语句 必须在这个构造函数的第一行
this.s=s;
}
}
public class love{
String Maybe="love";
public love(String Maybe){
System.out.println("Maybe=" + Maybe);
System.out.println("this.Maybe="+this.Maybe);
this.Maybe=Maybe;
System.out.println("this.Maybe="+this.Maybe);
}
public static void main(String[] args){
love s=new love("love you");
}
}
static 关键字
★类体定义的变量为成员变量，分实例变量和类变量（也叫静态变量）。用static定义的变量是类变量。两者的区别是：
不同的实例变量被分到不同的内存空间。类变量只有一个内存空间，即所有的对象都共用这个类变量。
类变量可能通过对象访问，也能通过类名直接访问。
★静态方法和实例方法的区别主要体现在两个方面：
在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。
静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。
静态方法不能直接访问非静太变量。
非静态方法可以直接访问静态变量。
package和import语句
包：是为了解决类的命名冲突引入的机制。
约定俗成的给包命名的方法：把公司的域名倒过来
Package语句作为java源文件的第一条语句。指明该文件中定义 的类所在的包。
Java编译器把包对应于文件系统的目录管理，package语句中，用‘.’来指明包（目录）的层次，例如package com.sun;则该文件中所有的类位于.comsun目录下
总结：
1.如果你要把一个类放在包下面，第一句写package,你编译出来的类必须位于正确的目录下面。
该类的源码可能会产生影响（解决办法：删除或转移到别的目录）
2.如果想在另一个类里面引用包里面的类，要把名字写全。（相当用文件的绝对路径访问）或者用import导入，但位于同一个包中的类不需要引入
3.必须class文件的最上层包中的父目录位于classpath下面。（注意点之一）
4.编译后，执行一个类的时候也需要把包名写全，不然无法执行。（注意点之二）
编译出来的类必须位于正确的目录下
I该类的源码可能会产生影响
II删除或转移到另外的目录
d.另外的类想访问的话：
I写全名
II引入 1）* 2）具体类名
III访问位于同一个包中的类不需要引入
e.必须class 文件的最上层包的父目录位于classipath下
补：执行一个类，需要写全包名
J2SDK中主要的包介绍（在jdk5.0/jre/lib/rt.jar里面，可用解压软件解开查看）
Java.lang－包含一些Java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能
Java.awt－包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。
Java.applet－包含applet运行所需的一些类
Java.net－包含执行与网络相关的操作的类
Java.io－包含能提供多种输入/输出功能的类
Java.util－包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数
其中就Java.lang包不用引入就能直接使用，其他包里面的类都要用import引入才能使用。
jar文件
命令： jar –cvf xx.jar *.*
访问控制
★Java权限修饰符public protected private 置于类的成员定义前，用来限定其他对象对象对该类对象成员的访问权限。
|
修饰符 |
类内部 |
同一个包 |
不同包子类 |
任何地方 |
|
private |
Yes |
|||
|
default |
Yes |
Yes |
||
|
protected |
Yes |
Yes |
Yes |
|
|
public |
Yes |
Yes |
Yes |
Yes |
★对于classr 权限修饰只可以用public 和default
public 类可以在任意地方被访问。
default 类只可以被同一个包内部的类访问。
类的继承
◇继承旧属性
◇添加新的属性
◇不支持多重继承
★使用extends关键字实现类的继承机制。
class 子类名 extends 父类名
{
……
}
★通过继承，子类自动拥有了基类的所有成员（变量和方法）
★Java只支持单继承，不允许多继承。一个子类只能有一个基类，一个基类可以派生多个子类。
★子类的继承性：不继承构造方法。子类继承父类的成员就好像子类自己声明定义的一样。
★子类和父类在同一包中的继承性：不能继承privat基类的变量和方法。其他的都可以。
★子类和父类不在同一包中的继承性：继承protected、public基类的变量和方法
方法的重写
在子类中可以根据需要对从基类中继承来的方法进行重写。
重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。
重写方法不能使用比被重写方法更严格的访问权限。
可以操作自身定义和继承下来的变量。
用super使用已被隐藏的父类方法。
成员变量的隐藏
子类可以从父类继承成员变量， 只要子类的成员父类中的成员变量同名时，就可以隐藏父类的成员变量。
关键字 super
super是一个引用。指向父类。可以和this比较。this指向本身的。
在 java类中 使用super来引用基类的成公。
继承中的构造方法
子类的构造的过程中必须调用其基类的构造方法。
子类可以在自己的构造方法中作用super（argumnet_list）调用基类的构造方法。
使用this(argumnet_list)调用本类的另外的构造方法。
如果调用super， 必须写在子类构造方法的第一行。
如果子类的构造方法中没有显示地调用基类构造方法。则系统默认调用基类无参数的构造方法。
如果子类构造方法中好即没有显式调用基类构造方法，而基类中又没有无参的构造方法，则编译出错。
Object类
Object是所有java类的根基类
如果在类的声明中未用extends关键字指明其基类，则默认基类为Object类
Public class Persom {
……
}
等价于：
Public class persom extends Object {
……
}
Object类中的hashCode和equals函数有着非常紧密的逻辑关系。当然这个逻辑关系是人赋予它的。在没有覆盖这两函数函数之前，hashCode返回的是地址，equals比较的也是两个应用对象的地址。 也就是说如果两个对象equals，那么hashcode值也应该一样。
对象内容的比较才是设计equals()的真正目的，Java语言对equals()的要求如下，这些要求是必须遵循的。否则，你就不该浪费时间：
对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
反射性：x.equals(x)必须返回是“true”。
类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
还有一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。
hashCode()的返回值和equals()的关系如下：
如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。
如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。
在Object类中定义的几个hashCode约定如下：
1. 在同一应用中，一个对象的hashCode函数在equals函数没有更改的情况下，无论调用多少次，它都必须返回同一个整数。
2. 两个对象如果调用equals函数是相等的话，那么调用hashCode函数一定会返回相同的整数。
3. 两个对象如果调用equals函数是不相等的话，那么调用hashCode函数不要求一定返回不同的整数。
我们在改写equals 和 hashCode 函数的时候，一定要遵守如上3条约定，在改写equals的同时也改写hashCode的实现，这样才能保证得到正确的结果。
对象转型
（一种向上转型 一种向下转型）
一个基类的引用类型变量可以“指向”其子类的对象。
一个基类的引用不可以访问其子类对象新增加的成员（属性和方法）
可以使用引用变量 instanceof 类名来判断该引用型 变量所“指向”的对象是否属于该或该类的子类。
子类的对象可以当作基类的对象业使用称作向上转型（upcasting）， 反之称这向下转型（downcasting）
多态
1 一定要有继承
2 一家要有重写
3 父类引用指向子类对象
抽象类
用abstract关键字来修饰一个类时，这个类叫体系抽象类;用abstract来修饰一个方法时，该方法叫做抽象方法。
含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须重写。
抽象类不能被 实例化。
抽象方法只需声明，而不需实现。
定义完抽象类后，就可以使用它。但是抽象类和普通类不同，抽象类不可以实例化。但是可以创建抽象类的对象变量，只是这个变量只能用来指向它的非抽象子类对象。
Public class UserAbstract
{
Public static void main(String[] args)
{
Animal animal1 = new Fish(); // Animail 是抽象类
animail1.brrath();
Animal animal2 = new Tiger();
animail2.breath();
}
}
需要注意的是，尽管animal存放的是tiger对象或是Fish对象，但是不能直接调用这些了类的方法，调用这项方法的时候仍然需要进行类型转换，正确的使用方法好下：
((Fish) animal1).swim();
((Tiger)animal2).tigerrun();
接口
接口是抽象方法和常量值的定义的集合
从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
接口特性
接口中声明的属性默认为public static final的; 也只能是 public static final的;
接口中只能定义抽象方法，而且这些方法默认为public的、也只能是public的;
接口可以继承其它的接口，并添加新的属性和抽象方法。
例如：
Int i; 实际效果是： public static final i;
Public interfaice Animal
{
// 接口中的变量
Int BIG_TYPE = 5;
// 用接口声明方法，只有方法的声明没有具体实现
void sleep();
void eat();
void breath();
}
多个无关的类可以实现同一个接口
一个类可以继承多个无关的接口。
与继承关系类似，接口与实现类之间存在多态性。
例如：
Class 类名 implements 接口1， 接口2
{
方法1(){};
方法2(){};
}
要注意的地方：
1 如果实现接口的类不是抽象类，它必须实现接口中定义的所有的方法，如果该类为抽象类，在它的子类甚至子类的了类中要实现接口中定义的方法。
2 实现接口的方法时必须使用相同的方法名和参数列表。
3 实现接口类中的方法必须被声明为public.因为在接口中的方法都定义为public.根据继承接的原则，访问范围只能放大，不能缩小。
接口之间也呆以有继承继承接口的接口拥有它的父接口的方法，它还可以定义自己的方法，实现这个子接口的类。
接口的另一个重要应用是用它来创建常量组，例如要用int类型的一组数来表示星期，而且这些天都是固定不需要改变的，就可以通过接口来实现。
//用接口来存放变量
Interface Weekdays
{
Int MONDAY = 1;
Int TUESDAY = 2;
Int WEDNESDAY = 3;
Int THUESDAY = 4;
Int FRIDAY = 5;
Int SATURDAY = 6;
Int SUNDAY = 7;
}
抽象类和接口的区别
1、Java接口和Java抽象类最大的一个区别，就在于Java抽象类可以提供某些方法的部分实现，而Java接口不可以，这大概就是Java抽象类唯一的优点吧，但这个优点非常有用。
如 果向一个抽象类里加入一个新的具体方法时，那么它所有的子类都一下子ic都得到了这个新方法，而Java接口做不到这一点，如果向一个Java接口里加入一个 新方法，所有实现这个接口的类就无法成功通过编译了，因为你必须让每一个类都再实现这个方法才行，这显然是Java接口的缺点。
2、一个抽象类的实现只能由这个抽象类的子类给出，也就是说，这个实现处在抽象类所定义出的继承的等级结构中，而由于Java语言的单继承性，所以抽象类作为类型定义工具的效能大打折扣。
在这一点上，Java接口的优势就出来了，任何一个实现了一个Java接口所规定的方法的类都可以具有这个接口的类型，而一个类可以实现任意多个Java接口，从而这个类就有了多种类型。
3、从第2点不难看出，Java接口是定义混合类型的理想工具，混合类表明一个类不仅仅具有某个主类型的行为，而且具有其他的次要行为。
4、结合1、2点中抽象类和Java接口的各自优势，具精典的设计模式就出来了：声明类型的工作仍然由Java接口承担，但是同时给出一个Java 抽象类，且实现了这个接口，而其他同属于这个抽象类型的具体类可以选择实现这个Java接口，也可以选择继承这个抽象类，也就是说在层次结构中，Java 接口在最上面，然后紧跟着抽象类，哈，这下两个的最大优点都能发挥到极至了。这个模式就是“缺省适配模式”。
在Java语言API中用了这种模式，而且全都遵循一定的命名规范：Abstract ＋接口名。
Java接口和Java抽象类的存在就是为了用于具体类的实现和继承的，如果你准备写一个具体类去继承另一个具体类的话，那你的设计就有很大问题了。Java抽象类就是为了继承而存在的，它的抽象方法就是为了强制子类必须去实现的。
使用Java接口和抽象Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明，以及数据类型的转换等。而不要用具体Java类进行变量的类型声明、参数是类型声明、方法的返还类型说明，以及数据类型的转换等。
内部类
内部类分为两在类。静态内部类和非静态内部类。非静态内部可以调用宿主类的所有变量和方法，并且像宿主类的其他非成员那样直接引用它们。静态内部类是用static修饰的类，静态内部不能直接访问其宿主类的成员，而必须通过对象来访问。
对于宿主类访问内部类的成员变量，静态内部类的静态变量可以直接用“类名.变量名”来调用，对于静态内部类的非静太变量则要生成它的对象，利用对象来访问。非静态内部类中不包含静态变量，所以必须用非内部类的对象来访问。
局部内部类
内部类不公可以在类中定义，也呆以在方法中定义。变量如果定义在类中，叫做成员变量；如果定义在方法中，叫做局部标量。内部类也是这样的，当定义在方法中时，叫做局部内部类。
对象克隆
****
最简单的例子：
public class HelloWorld{
public static void main(String args[]){
System.out.println("Hello World");
}
}
之所以给出这个例子是为让自己记住这个类名要和文件名一致.