要知道java中的代码是以类为单位的；而类中由两个关键部分组成：方法和属性。通过方法的调用可以改变属性的值。
a、通过类创建对象，调用对象的方法； 无论要多少对象、都可以通过这个类创建具体的对象，调用每一个对象所具有的方法（在类中已定义）就可以改变每个对象自己的属性。这就是类。关键字是class
其定义格式是：访问修饰符 class 类名（）{}
例：//定义一个类
public class Class(){
//创建一个对象
Student std=new Student();
//调用这个方法
std.study();
//若要再创建一个对象
Student std1=new Student();
//同样可以添加其方法，设置属性；就是通过添加方法和属性使得其对象不同
}
b、方法的基本结构；
方法在类中定义，通过对象的调用；方法的基本结构如下:
访问修饰符 返回值 方法名字（参数类型 参数变量名）{
方法体、、、
}
例：public int study(int score){
return score=+score;
}//此处返回值类型为int，故必须用return;若没有返回值则应该用void;
例：public void study(int score){
score =+score;
}
c、方法中有无参数，如果括号中有参数、在调用时必须传入指定类型的参数变量；
例：//设置有参数的方法
public void score(int grade){
scor=scor+grade;
}
//调用时，传入指定类型的参数
//先实例化一个对象
Student std=new Student();
//调用，并传入参数
std.score(3);
2、构造器方法
a、创建某个类的对象的一般格式是：
类名 变量名=new 类名（）；
例：Book bo=new Book();
//这里的Book（）就叫做Book类的构造器方法；
每一个类默认的都有一个无参构造器方法，即通过new 类名（）调用而创建对象。我们也可以自己给类重新定义构造器方法，这方法就叫做构造器方法的重载。
例：//创建一个树对象，使用无参构造器方法
Tree tree1=new Tree();
//创建一个树对象，使用一个参数的构造器方法
String name="榕树";
Tree tree2=new Tree(name);
//创建一个树对象，使用两个参数的构造器方法
String name="榕树"；
int high="5";
Tree tree3=new Tree(name,high);
使用构造器重载的好处是：在对象创建时，就可以初始对象内部属性的值；
b、方法重载：在一个类中可以定义多个同名，但参数类型和数量不同的方法这就叫做方法重载
例：//定义一个普通的方法
public void run(int speed){
sp=speed;
}
//定义一个方法，利用方法重载
public void run(String name){
na=name;
}//此为参数类型不同
//定义一个方法，使用方法重载
public void run(int speed,String name){
sp=speed;
na=name;
}
其调用时，参数应该相对应；构造器方法没有任何返回值的定义，且必须与类名相同。
构造器方法只有在创建对象时期调用---对于一个对象来说，它的构造器只能调用一次。
构造器和方法一样，都可以重载；它的主要用途是可以传入不同参数列表；使在创建对象时初始化对象的某些属性值；
this关键字
this在例中用来指代当前对象、形象地比如为“人类中的“我 例：//创建对象
int score ="80";
Student stu=new Student(score);
//构造时传入参数，初始化score的属性值
public Student (int score){
this.score=score
}
另一用途是在构造器中调用自己的另一构造器；这就是构造一般方法的区别：构造器中可以调用构造器，也可以调用一般方法；但在一般方法中，不能调用构造器。
c、值传递与引用传递
值传递：java中数据类型分为两大类：一类是引用类型，也叫做类型;其传递是通过类创建的对象的变量名字。另一类是原始类型，即八大数据类型；这些数据类型在传递时遵循“值传递”规则。
其中主要是引用传递：通过引用变量名，实际使用的是变量名所指向d 对象 ；同样的，在方法的参数中、参数是引用类型，传入的则只是一个对象名字的引用，而不是这个对象的本身；
例：//在一个类中定义一个方法
public class Teacher{
public void Test(Student stu){
String newScore="80";
stu.setScore(newScore);
}
}
//然后在主函数中调用，并传入一个对象；
public static void main(String [] args){
//创建对象
Student stu=new Student();
//调用前，设置名字
stu.setScore(50);
//实例化一类的对象
Teacher tea=new Teacher();
//传入对象引用名
tea.Test(stu);
int Score=stu.getScore();
}
3、类的继承和实现和作用
类继承的作用是减少重复代码的编写，充分利用代码的使用率；
类继承的实现是通过关键字extends帮子类继承父类中的方法和属性；
例：//一个子类继承父类
public class Son extends Father{
}//这样，子类就有了父类中的方法和属性；在后面的代码中可以直接调用父类中的方法和属性；
b、方法的重写：在类的继承中，为了使继承的对象与父类不同、可以重写子类的方法；重写子类的方法后，父类的方法则不再调用；
c、自动转型：子类类型自动转为父类类型；
例：//父类类型变量名用来引用子类对象
Father son=new Son();
此前提是前者必须是后者的父类；
转型之后，在使用son变量时、如果子类重写了父类的方法，则调用的就是子类中的实现，否则调用父类中的方法；通过转型之后、通过父类类型变量的引用，只能调用在父类中定义的方法，不能调用子类中自己的方法；子类一次只能继承一个父类，这就叫做单根继承。
d、多态的实现：
多态是：相同类型的对象调用相同的方法的时候，由于继承和重写机制、得到的结果不一定相同；
例：//先编写一个简单类
public class Son{
//实例化一个对象
Son son=new Son();
//设置名字
son.setName("children");
//父类中的方法
public void play(){
System.out.println("谁在玩"+getName());
}
}
//再编写一个子类，继承父类
public class xiaoming extends Son{
//重写父类中的方法
public void play(){
System.out.println("老大"+getName());
}
}
//再编写一个子类，继承父类
public class zhanghua extends Son{
//重写父类中的方法
public void play(){
System.out.println("老二"+getName());
}
}
//一个简单Father类，来使用Son类
public class Father{
//陪伴两孩子玩的游戏
public void playGream(Son a,Son b){
a.play();
b.play();
}
}
//主函数中实现
public static void main(String[] args){
//用父类变量名来引用子类对象
Son son1=new xiaoming();
son1.setName("小明");
Son son2=new zhanghua();
son2.setName("张华");
//创建一个父亲对象
Father fa=new Father();
//带两孩子玩耍
fa.playGrame(son1,son2);
}
e、接口的使用
接口：类作用有两个，一个生成对象调用其方法、另一个是用作给其它类来继承。而接口就是在某种特定的用途上、要求子类必须重写父类中的方法，从而需要的就是接口；其关键字是interface。它的规则是接口中定义的是一个没有任何方法体的实现方法；只要定义方法返回类型，方法名、参数表不能有实现。而且方法前是否写了public限定符，接口中的方法都是public型的。
接口的实现：使用关键字implements，实现类中、必须重写接口中定义的方法。
与类的继承相同的是：接口也可称作实现类的父类，实现类对象自动转型为接口类型；多态机制同子父类继承是同样原理。与类继承不同的是一个类可以实现多个接口；当一个类实现多个接口，自动转为某个接口类型时，就只能调用在其接口中定义的方法。
f、接口的继承
接口与接口之间也可以通过extends关键字来实现；与类不同的是接口同样可以继承多个接口；
例：一个Graphics继承Oval，rect等多个接口
public interface Graphics extends Oval,rect、、、{}
g、抽象类
抽象类是介于接口与类之间：竟可以定义已实现的方法，也可以定义像接口中没有实现的方法：继承的子类就必须实现。抽象类的关键字是abstract.
例：//定义一个抽象类
public abstract class Graphics {
//抽象方法的定义，继承的子类必须实现
public abstract void draw();
//也可以定义已实现的方法
public void setColor(int c){
this.color=c;
}
}
像这样，抽象类中定义的方法，如没有实现、前面就必须加上abstract关键字，这样就变成了抽象方法；当子类继承时、在子类中必须实现抽象类的abstract方法。
抽象类不能直接创建对象、当一个接口中定义有多个方法，子类都必须实现时、就要使用抽象类。
例如编写鼠标监听器实现类时，只需要自己的类extends MouseAdapter类、重写只需要使用的某一个方法即可、这样就不需要重写所有接口中定义的方法。
4、常用关键字
a、访问修饰符：public private protected它们的访问权限范围依次从大到小；
b、static关键字：使用static限定的有关方法称为静态方法或类方法。它与非静态的方法的区别是：非静态方法的调用必须通过创建类的对象调用；而static方法则不需要、直接使用类名.静态方法名（）调用即可。
static属性：可以不创建类的对象的而直接调用；另一个特征是：类的某一个对象的static属性值被改变后，这个类所有对象的static属性值都会被改变。
c、super关键字：它与this相比较、指 的是当前类的的父类对象；可以用来实现父类中的方法重写。
d、final关键字：当此关键字放在属性前面，属性的值就是常量、它的值就不可以改变；当放在方法的前面，其子类继承时、就不可以重写父类中的方法；所以常用来保护父类中不允许子类重写但有标识为public让外部调用的方法。
5、数组
数组是java中最基本的一种数据结构，数组一旦定义、它的长度是一定的；
其定义格式是：类型[] 数组变量名=new 类型[长度]；
例：int[] array=new int[30];
也可以仅定义一个数组变量名，再来赋值；
//定义一个int型的数组变量、并没有指向
数组对象；
int[] array;
//将数组变量名指向一个数组对象
array=new int [30];
b、多维数组:
格式如下：int[][] array=new int[2][3];
6、队列
队列的特点是先进先出；与数组不同的是队列没有长度限制；
[/align][align=center]