我们接着上次的继续整理
面向对象：面向对象是把问题域分解成各个对象，建立对象的目的不是为了完成一个步骤，
而是为了描叙某个事物在整个解决问题的步骤中的行为
面向过程：面向过程就是分析出解决问题所需要的步骤，
然后用方法把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了
类的定义：
publicclassAnimal
{
publicintlegs;
publicvoideat(){
System.out.println(“Eating.”);
}
publicvoidmove(){
System.out.println(“Moving.”);
}
}
legs是类的属性，也叫类的成员变量。
eat,move是方法也叫类的成员方法。
声明类：
语法格式：
[修饰符]class类名
{
[属性声明]
[构造器声明]
[方法声明]
}
说明：修饰符public：类可以被任意访问
类的正文要用{}括起来
举例：
publicclassPerson{
privateintage; //声明私有变量age
publicvoidshowAge(inti){//声明方法showAge
age=i;
}
}
属性声明：
语法格式：
[修饰符]类型属性名[=初值];
说明：修饰符private:该属性只能由该类的方法访问。
修饰符public:该属性可以被该类以外的方法访问。
类型：任何基本类型，如int、boolean或任何类。
举例：
publicclassPerson{
privateintage;//声明private变量age
publicStringname=“Lila”;//声明public变量name
}
声明方法：
语法格式：
修饰符返回类型方法名([参数表]){
[语句]
}
说明：修饰符：public,private,protected等。
返回类型：return语句传递返回值。没有返回值：void。
举例：
publicclassPerson{
privateintage;
publicintgetAge(){
returnage;
}//声明方法getAge
publicvoidsetAge(inti){//声明方法setAge
age=i;//将参数i的值赋给类的成员变量age
}
}
类的访问机制：
在一个类中的访问机制：类中的方法可以直接访问类中的成员变量。（有一个例外）
在不同类中的访问机制：先创建要访问类的对象，再用对象访问类中定义的成员。
匿名对象：
我们也可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象，如：newPerson().shout();
如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。
我们经常将匿名对象作为实参传递给一个方法调用。
方法
返回值类型方法名（参数类型形式参数1，参数类型形式参数2，….）｛
程序代码
return返回值；
｝
其中：
形式参数：在方法被调用时用于接收外部传入的数据的变量。
参数类型：就是该形式参数的数据类型。
返回值：方法在执行完毕后返还给调用它的程序的数据。
返回值类型：方法要返回的结果的数据类型。
实参：调用方法时实际传给方法形式参数的数据。
方法的重载
方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要它们的参数个数或类型不同即可。如：
publicclassTest
{
publicstaticvoidmain(String[]args){
intisum;
doublefsum;
isum=add(3,5);
isum=add(3,5,6);
fsum=add(3.2,6.5);
}
publicstaticintadd(intx,inty){
reutrnx+y;
}
publicstaticintadd(intx,inty,intz){
returnx+y+z;
}
publicstaticdoubleadd(doublex,doubley){
returnx+y;
}
}
final：
在Java中声明类、属性和方法时，可使用关键字final来修饰。
final标记的变量(成员变量或局部变量)即成为常量，只能赋值一次。
final标记的类不能被继承。提高安全性，提高程序的可读性。
final标记的方法不能被子类重写。增加安全性。
final标记的成员变量必须在声明的同时或在每个构造方法中显式赋值，然后才能使用。
举例：
publicfinalclassTest{
publicstaticinttotalNumber=5;
publicfinalintid;
publicTest(){
id=++totalNumber;//只能在构造方法中给final变量赋值
}
publicstaticvoidmain(String[]args){
Testt=newTest();
System.out.println(t.id);
finalinti=10;
finalintj;
j=20;
j=30;//非法
}
static：
在Java类中声明变量、方法和内部类时，可使用关键字static做为修饰符。
static标记的变量或方法由整个类(所有实例)共享，如访问控制权限允许，可不必创建该类对象而直接用类名加‘.’调用。
static成员也称类成员或静态成员，如：类变量、类方法、静态方法等。
classCircle
{
privatedoubleradius;
publicCircle(doubleradius){this.radius=radius;}
publicdoublefindArea(){returnMath.PI*radius*radius;}
}
创建两个Circle对象
Circlec1=newCircle(2.0); //c1.radius=2.0
Circlec2=newCircle(3.0); //c2.radius=3.0
Circle类中的变量radius是一个实例变量(instancevariable)，它属于类的每一个对象，不能被同一个类的不同对象所共享。
上例中c1的radius独立于c2的radius，存储在不同的空间。c1中的radius变化不会影响c2的radius，反之亦然。
如果想让一个类的所有实例共享数据，请用类变量
类变量：类变量（类属性）由该类的所有实例共享
publicclassPerson{
privateintid;
publicstaticinttotal=0;
publicPerson(){
total++;
id=total;
}
}
类属性类似于全局变量
类属性的应用举例
classPerson{
privateintid;
publicstaticinttotal=0;
publicPerson(){
total++;
id=total;
}
publicstaticvoidmain(Stringargs[]){
PersonTom=newPerson()
Tom.id=0;
total=;//不用创建对象就可以访问静态成员
}
}
publicclassOtherClass{
publicstaticvoidmain(Stringargs[]){
Person.total=;//不用创建对象就可以访问静态成员
//访问方式：类名.类属性类名.类方法
System.out.println(Person.total);
Personc=newPerson();
System.out.println(c.total); //输出
}
}
类方法
没有对象的实例时，可以用类名.方法名()的形式访问由static标记的类方法。
classPerson{
privateintid;
privatestaticinttotal=0;
publicstaticintgetTotalPerson(){
returntotal;
}
publicPerson(){
total++;
id=total;
}
}
publicclassTestPerson{
publicstaticvoidmain(String[]args){
System.out.println(Numberoftotalis+Person.getTotalPerson());
//没有创建对象也可以访问静态方法
Personp1=newPerson();
System.out.println(Numberoftotalis+Person.getTotalPerson());
}
}
在static方法内部只能访问类的static属性，不能访问类的非static属性。
classPerson{
privateintid;
privatestaticinttotal=0;
publicstaticintgetTotalPerson(){
id++; //非法
returntotal;
}
publicPerson(){
total++;
id=total;
}
}
因为不需要实例就可以访问static方法，因此static方法内部不能有this,(也不能有super?)
classPerson{
privateintid;
privatestaticinttotal=0;
publicstaticvoidsetTotalPerson(inttotal){
this.total=total;//非法，在static方法中不能有this，也不能有super
}
publicPerson(){
total++;
id=total;
}
}
publicclassTestPerson{
publicstaticvoidmain(String[]args){
Person.setTotalPerson();
}
}
在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。
静态方法不能以任何方式引用this和super关键字。与上面的道理一样，因为静态方法在使用前不用创建任何实例对象，当静态方法被调用时，this所引用的对象根本就没有产生。
main()方法是静态的，因此JVM在执行main方法时不创建main方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，这种情况，我们在以后的例子中会多次碰到。
类属性，类方法的设计思想：
类属性作为该类各个对象之间共享的变量。在设计类时,分析哪些类属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。
如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用
练习1：编写一个类，实现银行账户的概念，包含的属性有“帐号”、“密码”、“存款余额”、“利率”、“最小余额”，定义封装这些
属性的方法。账号要自动生成。
编写主类，使用银行账户类，输入、输出3个储户的上述信息。
考虑：哪些属性可以设计成static属性。Bank.java
静态块
一个类中可以使用不包含在任何方法体中的静态代码块(staticblock)，当类被载入时，静态代码块被执行，且只被执行一次，静态块经常用来进行类属性的初始化。
static块通常用于初始化static(类)属性
classPerson{
publicstaticinttotal;
static{
total=;//为total赋初值
}
……//其它属性或方法声明
}
静态块举例
classPerson{
publicstaticinttotal;
static{
total=;
System.out.println(instaticblock!);
}
}
publicclassTest{
publicstaticvoidmain(String[]args){
System.out.println(total=+Person.total);
System.out.println(total=+Person.total);
}
}
输出：
instaticblock
total=
total=
单子Singleton设计模板：
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就想是经典的棋谱，不同的棋局，我们用不同的棋谱，免得我们自己再去思考和摸索。
所谓类的单态设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造方法的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类内部仍可以产生该类的对象。因为在类的外部开始还无法得到类的对象，只能调用该类的某个静态方法以返回类内部创建的对象，静态方法只能访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。
classSingle{
privatestaticSingleonlyone=newSingle();//私有的，只能在类的内部访问
privateStringname;
publicstaticSinglegetSingle(){//getSingle()为static，不用创建对象
//即可访问
returnonlyone;
}
privateSingle(){}//private的构造器，不能在类的外部创建该类的对象
}
publicclassTestSingle{
publicstaticvoidmain(Stringargs[]){
Singles1=Single.getSingle();//访问静态方法
Singles2=Single.getSingle();
if(s1==s2){
System.out.println(s1isequalstos2!);
}
}
}
理解main方法的语法：
由于java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数。
命令行参数用法举例
publicclassCommandPara{
publicstaticvoidmain(String[]args){
for(inti=0;iargs.length;i++){
System.out.println(args[+i+]=+args);
}
}
}
//运行程序CommandPara.java
javaCommandParalisabilyMrBrown
//输出结果：
args[0]=lisa
args[1]=bily
args[2]=MrBrown
抽象类(abstractclass)：
随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。
用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，该方法叫做抽象方法。
抽象方法：只有方法的声明，没有方法的实现。以分号结束。
abstractintabstractMethod1(inta);
含有抽象方法的类必须被声明为抽象类。
抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。
不能用abstract修饰私有方法，构造方法，静态方法。
抽象类举例
abstractclassA{
abstractvoidm1();
publicvoidm2(){
System.out.println(A类中定义的m2方法);
}
}
classBextendsA{
voidm1(){
System.out.println(B类中定义的m1方法);
}
}
publicclassTest{
publicstaticvoidmain(Stringargs[]){
Ac=newB();
c.m1();
c.m2();
}
}
抽象类应用：
抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。
在航运公司系统中，Vehicle类需要定义两个方法分别计算运输工具的燃料效率和行驶距离。
问题：卡车(Truck)和驳船(RiverBarge)的燃料效率和行驶距离的计算方法完全不同。Vehicle类不能提供计算方法，但子类可以。
解决方案：
Java允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。
Vehicle是一个抽象类，有两个抽象方法。
publicabstractclassVehicle{
publicabstractdoublecalcFuelEfficiency(); //计算燃料效率的抽象方法
publicabstractdoublecalcTripDistance(); //计算行驶距离的抽象方法
}
publicclassTruckextendsVehicle{
publicdoublecalcFuelEfficiency(){//写出计算卡车的燃料效率的具体方法}
publicdoublecalcTripDistance(){//写出计算卡车行驶距离的具体方法}
}
publicclassRiverBargeextendsVehicle{
publicdoublecalcFuelEfficiency(){//写出计算驳船的燃料效率的具体方法}
publicdoublecalcTripDistance(){//写出计算驳船行驶距离的具体方法}
}
注意：抽象类不能实例化newVihicle()是非法
接口：
有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
接口(interface)是抽象方法和常量值的定义的集合。
从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
接口定义举例
publicinterfaceRunner{
intid=1;
publicvoidstart();
publicvoidrun();
publicvoidstop();
}
接口的特点：
用interface来定义。
接口中的所有成员变量都默认是由publicstaticfinal修饰的。
接口中的所有方法都默认是由publicabstract修饰的。接口没有构造方法。
实现接口的类中必须提供接口中所有方法的具体实现内容。
多个无关的类可以实现同一个接口
一个类可以实现多个无关的接口
与继承关系类似，接口与实现类之间存在多态性
接口也可以继承另一个接口，使用extends关键字。
实现接口的类中必须提供接口中所有方法的具体实现内容。
多个无关的类可以实现同一个接口
一个类可以实现多个无关的接口
与继承关系类似，接口与实现类之间存在多态性
定义Java类的语法格式：
modifierclassname[extendssuperclass]
[implementsinterface[,interface]*]{
declarations*
}
接口应用举例：
publicinterfaceRunner{
publicvoidstart();
publicvoidrun();
publicvoidstop();
}
publicclassPersonimplementsRunner{
publicvoidstart(){
//准备工作：弯腰、蹬腿、咬牙、瞪眼 //开跑
}
publicvoidrun(){
//摆动手臂
//维持直线方向
}
publicvoidstop(){
//减速直至停止、喝水。
}
}
一个类可以实现多个无关的接口
interfaceRunner{publicvoidrun();}
interfaceSwimmer{publicdoubleswim();}
classAnimal{publicinteat(){…}}
classPersonextendsAnimalimplementsRunner,Swimmer{
publicvoidrun(){……}
publicdoubleswim(){……}
publicinteat(){……}
}
与继承关系类似，接口与实现类之间存在多态性
publicclassTest{
publicstaticvoidmain(Stringargs[]){
Testt=newTest();
Personp=newPerson();
t.m1(p);
t.m2(p);
t.m3(p);
}
publicStringm1(Runnerf){f.run();}
publicvoidm2(Swimmers){s.swim();}
publicvoidm3(Animala){a.eat();}
}
接口的其他问题
如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类。
接口也可以继承另一个接口，使用extends关键字。
interfaceMyInterface
{
Strings=“MyInterface”;
publicvoidabsM1();
}
interfaceSubInterfaceextendsMyInterface
{
publicvoidabsM2();
}
publicclassSubAdapterimplementsSubInterface
{
publicvoidabsM1(){System.out.println(“absM1”);}
publicvoidabsM2(){System.out.println(“absM2”);}
}
实现类SubAdapter必须给出接口SubInterface以及父接口MyInterface中所有方法的实现。
小编先整理这么多，求感兴趣的同学多多