if（3==j）{
breakloop;//---------------loop为标签只能用在循环语句中，循环//嵌套中用于跳到外层循环
}
}
}
辨析：
intx,a=6,b=7;
x=a+++b++;//----------a=7,b=8,x=13
intx=6;x=~x;//----------------6的二进制0110取反得11001再转成补码（取反加一）10111＝－7
四·数组
声明数组
1）一组相同类型（可以是类）数据的集合;
2）一个数组是一个对象;
3）声明一个数组没有创建一个对象;
4）数组能以下列形式声明：
int[]i或inti[]
Car[]c或Carc[]
*C++中只能Carc[]
*JAVA中推荐用Car[]c;
创建数组
1）创建基本数据类型数组int[]i=newint[2];
2）创建引用数据类型数组Car[]c=newCar[100];
3）数组创建后有初始值。
数字类型为0布尔类型为false引用类型为null
初始化数组
1）初始化、创建、和声明分开
int[]i;
i=newint[2];
i[0]=0;
i[1]=1;
2）初始化、创建、和声明在同一时间
int[]i={0,1};
Car[]c={newCar（）,newCar（）};
多维数组
1）有效
int[][]i1=newint[2][3];
int[][]i2=newint[2][];
i2[0]=newint[2],i2[1]=newint[3];
*C++中int[][]=newint[][3];有效
2）无效
int[][]i1=newint[][3];
3）数组长度------------数组的属性length
int[]i=newint[5];
intlen=i.length;//len=5;
Student[][]st=newStudent[4][6];
len=st.length;//len=4;
len=st[0].length;//len=6;
请问以下哪段代码哪个可正确执行？
（a,c）
1.achar[]i={'a','b'};i=newchar[]{'b','c'};
bchar[]i={'a','b'};i={'b','c'};
cchar[]i=newchar[2];i=newchar[]{'b','c'};
dchar[]i=newchar[2];i={'b','c'};
数组拷贝
System.arrayCopy（Object src,int srcPos,Object dest,int destPos,int length）;
拷贝一个数组到另一个数组。
五·对象和类
面向对象与面向过程
为什么要使用面向对象：
首先，面向对象符合人类看待事物的一般规律。
对象的方法的实现细节是屏蔽的，只有对象方法的实现者了解细节。
方法的定义非常重要。
方法有参数，也可能有返回值。
注意区分：
对象（本身）、对象的实现者、对象的调用者。
分析对象主要从方法开始。
我们通过类来看待对象，类是对象的抽象。
其次，采用面向对象方法可以使系统各部分各司其职、各尽所能。
对象之间的耦合性一定要低（比如不同硬盘和不同主板之间的关系）。
这样才能使每个对象本身做成最好的。
对于对象的要求：
高内聚、低耦合，这样容易拼装成为一个系统。
实现高内聚就是要最大限度低提高复用性（复用性好是因为高内聚）。
可复用性是OOP的基础。
比较面向过程的思想和面向对象的思想：
面向过程的思想：
由过程、步骤、函数组成，以过程为核心；
面向对象的思想：
以对象为中心，先开发类，得到对象，通过对象之间相互通信实现功能。
面向过程是先有算法，后有数据结构。
面向对象是先有数据结构，然后再有算法。
在用面向对象思想开发的过程中，可以复用对象就进行复用，如无法进行复用则开发新的对象。
开发过程是用对个简单的对象的多个简单的方法，来实现复杂的功能。
从语法上来看，一个类是一个新的数据类型。
在面向对象编程中，除了简单数据类型，就是对象类型。
定义类的格式：
classStudent{
代码
}
注意类名中单词的首字母大写。
对象的概念
什么是对象：
EVERYTHINGISOBJECT（万物皆对象）
所有的事物都有两个方面：
1．有什么（属性）：
用来描述对象。
2．能够做什么（方法）：
告诉外界对象有那些功能。
后者以前者为基础。
*一个对象的属性也可以是一个的对象。
这是一种对象的关联（associate）
publicclassStudent{
privateStringname;---------对象
privateintage;---------------基本类型
privategender;
publicvoidstudy（）{}---------方法
}
成员变量和局部变量
1．实例变量：
定义在类中但在任何方法之外。
（New出来的均有初值）
实例变量中对象默认值为null。
实例变量的作用域在本类中完全有效，当被其他的类调用的时候也可能有效。
2．局部变量：
定义在方法之中的变量。
局部变量要先赋值，再进行运算，而实例变量均已经赋初值。
这是局部变量和实例变量的一大区别。
局部变量不允许范围内定义两个同名变量。
实例变量和局部变量允许命名冲突，但在局部变量的作用域内局部变量优先，访问实例变量是使用this.variableName。
成员方法
方法定义
1）格式（[argument_list>]）[throws]{}
例如：
publicStringgetName（）{returnname;}
2）当没有返回值时，返回类型必须被定义为void。
3）构造方法没有返回类型。
4）返回类型必须与方法相邻，其他修饰符号可以调换位置。
参数传递
Java语言总是使用传值调用。
这意味着方法得到的只是所有参数值的拷贝。
因此，方法不能修改传递给它的任何参数变量的内容。
对于对象类型的参数传递的也是该对象的引用值，方法中并不能改变对象变量，但能通过该变量调用对象的方法或修改对象的成员。
This关键字
1）this是个隐式参数，代表被构造的对象;
publieclassPerson{
privateStringname;
publicvoidsetName（Stringname）{
this.name=name;-------------this.name为成员变量
}
}
2）如果构造器的第一个语句具有形式this（...），那么这个构造器将调用同一类中的其他构造器。
3）在构造器中this（）必须放在方法的第一行。
*Super关键字也是个隐形参数，代表被构造对象的父类。
同样也必须在构造方法的第一行
访问控制符
权限高
public全部可见
protected本类可见，同包可见，子类可见
default本类可见，同包可见
private本类可见
权限低
构造方法
构造方法是在生成对象的过程中调用的方法，但构造方法并不能创建对象。
其特点为：
1．构造方法没有返回值。
2．构造方法的方法名与类名相同。
格式为：
publicClassName（）{}
构造方法也可以是其他的限制符――privateprotecteddefaultprivate一般用在singleton模式中。
在一个对象的生成周期中构造方法只用一次，一旦这个对象生成，那么这个构造方法失效。
*接口不能创建实例，因为没有构造方法
可以构造多个构造方法，但多个构造方法的参数表一定不同，参数顺序不同即属于不同的构造方法：
-----------------------构造方法的重载
publicstudent（stringname,inta）{
}
publicstudent（inta,stringname）{
}
为两个不同的构造方法。
如果我们未给系统提供一个构造方法，那么系统会自动提供一个为空的构造方法。
如果我们提供了有参的构造方法，那么系统不会再提供无参的构造方法了。
这样当被子类继承时，如果子类构造方法不人为调用父类的有参构造方法就会出现异常。
数据的隐藏―――封装
publicclassPerson{
privateStringname;----------------------数据的隐藏
privateintage;
publicStringgetName（）{-------------------方法尽量公开
returnname;
}
publicintgetAge（）{
returnage;
}
}
方法的重载
Overloading在一个类中可以定义多个同名方法，各个方法的参数表一定不同。
但修饰词可能相同，返回值也可能相同。
在程序的编译过程中根据变量类型来找相应的方法。
Overloading被认为是编译时的多态。
Overloading只是为方便程序员编程的解决方法，编译之后的方法名实际加上了各参数类型成为唯一的名字。
普通方法
publicvoidaa（inta,doubleb）throwsIOException{}
privateintaa（doublea,intb）{}
protecteddoubleaa（Stringa,Stringb）{}
构造方法也可以实现overloading。
例：
publicvoidteach（）{};
publicvoidteach（inta）{};
publicvoidteach（Stringa）{}为三种不同的方法。
Overloading方法对于不匹配的参数是从低向高转换的。
Byte—short—float—int—long—double。
六·高级语言特性
封装（encapsulation）
a.把数据和行为结合在一个包中，并对对象的使用者隐藏数据的实现过程。
对象中的数据称为对象的实例字段（instancefield）,操作数据的函数和过程称为对象的方法（method）。
一个特定对象就是类在实例字段上有着特定值的某个实例。
b.实现封装的关键在于绝不让方法直接访问其他类的实例字段。
继承（inherit）
JAVA继承特点
1.在现有类的基础上构建新的类。
当继承一个现有类时，就重用（继承）了那个类的方法和字段，同时，还可以向新类中增添新的方法和字段。
2.在通过扩展超类来定义子类时，只需要说明子类和超类的区别就行。
所以在设计类时，把最通用的方法放在超类中，把更专门的方法放在子类中。
3.JAVA中不允许多继承，一个类有且只有一个父类。
所以JAVA的数据结构为树型结构，而非网状。
（JAVA通过接口实现多继承）
父类（SuperClass）和子类（SubClass）的关系
父类的非私有化属性（不同包的子类无法访问default修饰符）和方法可以默认继承到子类。
ClassSonextendsFather{
}
而如果父类中的私有方法被子类调用的话，则编译报错。
父类的构造方法子类不可以继承，更不存在覆盖的问题。
所以子类构造方法默认调用父类的无参构造方法。
（所以养成写无参构造的习惯）
如果子类访问父类的有参构造方法，必须在子类构造方法第一行使用super（参数）
当构造一个对象的时候，系统先构造父类对象，再构造子类对象。
系统构造一个对象的顺序
1先为最里层类成员属性赋初值；
2再构造该类对象；
3返回外层，重复1（上一层类）、2步骤直到完成最外层类的构造。
多态（polymorphism）
多态：
一个对象变量可以指向多种实际类型的现象。
方法的覆盖（overridding）
当子类从父类继承一个无参方法，而又定义了一个同样的无参方法，则子类新写的方法覆盖父类的方法，称为覆盖。
（注意返回值类型也必须相同，否则编译出错。
）
如果方法参数表不同，则成重载。
特点：
1．对于方法的访问限制修饰词，子类方法要比父类的访问权限更高。
父类为public，那么子类为private则出现错误。
2．子类抛出的异常应该是父类抛出的异常或其子类。
多态的分类
多态分两种：
1编译时多态：
编译时动态重载；
2运行时多态：
指一个对象可以具有多个类型。
猫，小鸟，狗都是动物，都可以安上动物的标签。
InterfaceAnimal{}
ClassCarimplementsAnimal{}
ClassBirdimplementsAnimal{}
ClassDogimplementsAnimal{}
方法中
Animala=newCar（）;
Animalb=newBird（）;
Animalc=newDog（）;
运行时多态的三原则
1.对象不变；（改变的是主观认识）
2.对于对象的调用只能限于编译时类型的方法，如调用运行时类型方法报错。
在上面的例子中：
Animala=newDog（）；对象a的编译时类型为Animal，运行时类型为dog。
注意：
编译时类型一定要为运行时类型的父类或者同类型。
对于语句：
Dogd=（Dog）a。
将d强制声明为a类型，此时d为Dog（），此时d就可以调用运行时类型。
注意：
a和d指向同一对象。
3.动态类型判定实际调用的方法。
即它调用覆盖后的方法。
关系运算符：
instanceof
instanceofAnimal;（这个式子的结果是一个布尔表达式）
上面语句是判定a是否可以贴Animal标签。
如果可以贴则返回true，否则返回false。
在上面的题目中：
ainstanceofAnimal返回 True，
ainstanceofDog也返回 True，
用于判定前面的对象是否是后边的类或者子类。
Animala=newCar（）;
If（ainstanceofDog）{
Dogb=（Dog）a;
}
elseif（ainstanceofCar）{
Carc=（Car）a
}
不会错。
静态变量，方法和类
静态变量
Staticintdata语句说明data为类变量，为一个类的共享变量，属于整个类。
例：
ClassM{
staticintdata;
}
Mm1=newM（）;Mm2=
升级会员 