COREJAVA第三章
第三章、 面向对象（上）
Ø 什么是面向对象
Ø 类和对象
Ø 构造方法
Ø this引用句柄
Ø 方法的数据类型传递
Ø static关键字
Ø 内部类
Ø JAVA中的文档注释
一、什么是面向对象？
面向过程：
先确定算法在确定数据结构。
面向过程强调的是谓语与宾语的关系。
面向对象：
面向对象强调的是主语与谓语的关系。
先确定数据结构再确定算法。
特点：封装、抽象、继承、多态。
二、类和对象
类概念上的定义是：类是对某一类事物的描述。
对象是实际存在的该类事物的个体。
如果把对象比作汽车，类就是汽车的设计图纸。
面向对象重点是类的设计。
（1）类的定义
Java中类包括成员变量和成员方法两部分。类的成员变量可以是基本数据类型的数据或数组，也可以是一个类的实例；类的方法用于处理该类的数据。
类的定义格式：
[类的修饰字] class 类名称 [extends 父类名称][implements 接口名称列表]
{
变量定义及初始化；
方法定义及方法体；
}
解释：
类的修饰字：
Ø public：允许其他类（没有限制）访问本类，一个源文件仅可以有一个public类，且与文件同名。
Ø default（缺省）：可被当前包中的其他类访问；如果定义时没有public，则所有的类都是default;
Ø abstract：没有实例的抽象概念类
Ø final（最终的类）：不能再被扩展，不能被继承；易于安全性的实现，或用于创建固定功能的类
Ø 父类继承声明：extends 父类名（见继承）
Ø 实现接口(interface)：implements 接口名
成员变量的定义格式：
[变量修饰符] 变量数据类型 变量名1,变量名2[=变量初值]…;
变量修饰符：
Ø public：可被所有其他类引用
Ø protected：该类自身、子类、同一包中的其他类
Ø private：仅可被该类自身引用和修改，不能被其他任何类（包括子类）引用
Ø default(缺省)：本包中的类
Ø static: 类变量或类字段，对所有的实例一致，引用时前缀可使用类名或对象名，属于类。
Ø final：数值不变常量，定义同时应对其进行初始化
修饰符 |
类 |
子类 |
包 |
所有类和包 |
public |
√ |
√ |
√ |
√ |
private |
√ |
|||
protected |
√ |
√ |
√ |
|
default(省略) |
√ |
√ |
成员方法的定义格式：
[方法修饰字] 返回类型 方法名称(参数1,参数2,…) [throws Exception ]
{
语句体； … //方法体：方法的内容
}
方法修饰符：
Ø public ,private ,protected,default与成员变量的作用域一样。
Ø static：静态方法，又称类方法
A．使用类名或对象名作为前缀，建议使用类名
B．在方法体中只能使用static变量和static方法或访问自己的局部变量
Ø abstract：只有接口没有语句，要在子类中通过重新定义（override）来实现
Ø final：不能被重新定义（override）
Ø syschronized:同步方法用于多线程编程。多线程在运行时，可能会同时存取一个数据。为避免数据的不一致性，应将方法声明为同步方法，对数据进行加锁，以保证线程的安全。
Ø throws：通告本方法中会产生的例外（异常）类型，提醒调用者要对相应的可能例外进行处理。当执行此方法并发生了例外时，程序会转入调用者编制的例外处理程序段。
例：
A．类可以将数据和函数封装在一起，其中数据表示类的属性，函数表示类的行为。定义类就是要定义类的属性与行为（方法）。
class Person{ //定义一类
int age; //定义一成员变量。
//一个类中的成员函数可以访问同类中的任何成员（包括成员变量和成员函数）
void shout(){ //定义一成员函数。
System.out.println(“my age is”+age);
}
}
注意：如果类的一个方法中有与成员变量同名的局部变量，该方法中对这个变量的访问是局部变量而不是成员变量。
class Person{ //定义一类
int age; //定义一成员变量。
void shout(){ //定义一成员函数。
int age=60;//定义一局部变量
System.out.println(“my age is”+age);
}
}
（2）对象的创建
对象的创建即对类的属性和行为的实现。（类的实例化）
声明一个类的变量，就是声明了该类的一个实例，即对象。创建对象包括声明对象、实例化对象即为对象分配存储空间两步 。
对象格式:
类名 对象名 = new 类名()；
如Person p1=new Person();
对象被创建时，会对其中各种类型的成员变量自动进行初始化赋值。
（3）对象的使用
创建新的对象之后,我们就可以使用“ 对象名.对象成员 ”的格式，来访问对象的成员（包括属性和方法）。
例:
class TestPerson
{
public static void main
(String[] args)
{
Person p1 = new Person();
Person p2 =new Person();
p1.age = -30;
p1.shout();
p2.shout();
}
}
（4）对象的生命周期
第一种情况：
第二种情况：
第三种情况：
（5）对象的清除
Ø Java运行时系统通过垃圾自动回收机制周期性地释放无用对象所使用的内存，完成垃圾的自动回收。
Ø 当一个对象的引用为空时，该对象称为一个无用对象。
Ø finalize（）方法
对象被当成垃圾从内存释放前调用，而不是对象被当成垃圾前调用。垃圾回收器的启用不由程序员自己控制，也无规律可循，并不会一产生垃圾，它就被唤起，甚至有可能到程序终止，它都没有启动的机会。
例：
class Person
{
public void finalize()
{
System.out.println("the object is going!");
}
public static void main(String [] args)
{
new Person();
new Person();
new Person();
System.out.println("the program is
ending!");
}
}
Ø System.gc（）的作用
System.gc（）的作用是强制启动垃圾回收器，释放垃圾所占的内存空间。
例：
class Person
{
public void finalize()
{
System.out.println("the object is going!");
}
public static void main(String [] args)
{
new Person();
new Person();
new Person();
System.gc();
System.out.println("the program is ending!");
}
}
（6）对象的比较
A、“= =”运算符 ，用于比较两个变量（基本数据类型和引用数据类型变量）的值是否相等。
例：
class Compare{
public static void main(String[] args){
String str1 = new String("abc");
String str2 = new String("abc");
String str3 = str1;
if(str1==str2){
System.out.println("str1==str2");
}else{
System.out.println("str1!=str2");}
if(str1==str3){
System.out.println("str1==str3");
}else{
System.out.println("str1!=str3");}
}}
B、equals()方法是String 类的一个成员方法，用于比较两个引用变量所指向的对象的内容是否相等。
class Compare{
public static void main(String[] args){
String str1 = new String("abc");
String str2 = new String("abc");
String str3 = str1;
if(str1.equals(str2)){
System.out.println("str1 equal str2");
}else{
System.out.println("str1 not equal str2");}
if(str1.equals(str3)){
System.out.println("str1 equal str3");
}else{
System.out.println("str1 not equal str3");}
}}
（7）匿名对象
创建完对象后，在调用该对象的方法时，可以不定义对象的引用变量，而直接调用这个对象的方法。这样的对象叫匿名对象。
例：
Person p1=new Person();
p1.shout();
改写成：
new Person().shout(); //这个方法执行完，这个对象也就变成了垃圾。
使用匿名对象的情况：
（1）如果一个对象只需要一次方法调用，那么就可以使用匿名对象。
（2）将匿名对象作为实参传递给一个函数调用，比如程序中有一个getSomeOne 函数，要接收一个Person类对象作为参数，函数定义如下：
public static void getSomeOne(Person p)
{
....
}
可以用下面的语句调用这个函数
getSomeOne(new Person());
三、构造方法
（1）构造方法特点:
Ø 它具有与类相同的名称。
Ø 它不含返回值。
Ø 它不能在方法中用return语句返回一个值。
（2）构造方法作用:
Ø 对类的成员变量进行初始化工作。
（3）构造方法重载:
Ø 和一般的方法重载一样，重载的构造方法具有不同个数或不同类型的参数，编译器就可以根据这一点判断出用new 关键字产生对象时，该调用哪个构造方法了。产生对象的格式是：new 类名(参数列表);
Ø 2、重载构造方法可以完成不同初始化的操作， 如：p3=new Person(“Tom”,18);语句，会做这样几件事：创建指定类的新实例对象，在堆内存中为实例对象分配内存空间，并调用指定类的构造方法，最后将实例对象的首地址赋值给引用变量p3。
（4）构造方法应注意:
Ø java每个类里都至少有一个构造方法。
Ø 可以自定义类的构造方法。
Ø 声明构造方法，如无特殊需要，应使用public关键字。
四、this引用句柄
关键字this用来指向当前对象或类的实例变量。
格式：this.成员（成员变量和方法）
例：
class TestThis{
int day = 1;
void setDay(int day){
this.day = day;
}
}
五、方法的数据类型传递
（1）基本类型的参数传递：
方法的形式参数就相当于方法中定义的局部变量，方法调用结束时也就被释放了，不会影响到主程序中同名的局部变量。
例：
class PassValue
{
public static void main(String [] args)
{
int x = 5;
change(x);
System.out.println(x);
}
public static void change(int x)
{
x = 3;
}
}
（2）引用数据类型的传递：
对象的引用变量并不是对象本身，它只是对象的引用句柄（名称）。例：
class PassRef
{
int x ;
public static void main(String [] args)
{
PassRef obj = new PassRef();
obj.x = 5;
change(obj);
System.out.println(obj.x);
}
public static void change(PassRef obj)
{
obj.x=3;
}
}
六、static关键字
（1）静态变量：
Ø 静态变量又称类变量，被所有对象所共享，用static关键字修饰，在声明的同时为其分配内存空间并初始化。类只能被装载一次，所以静态变量在内存中只有一份拷贝。
Ø 注意：我们不能把任何方法体的变量声明为静态，如下面的形式：
fun(){ static int i=0; }
（2）静态方法：
Ø 静态方法又称类方法，被所有对象所共享，用static关键字修饰。
Ø 在静态方法里只能直接调用同类中其它的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象。
Ø 静态方法不能以任何方式引用this和super关键字，因为静态方法在使用前不用创建任何实例对象，当静态方法被调用时，this所引用的对象根本就没有产生。
Ø main() 方法是静态的，因此JVM在执行main方法时不创建main方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。
（3）静态代码块：
Ø 一个类中可以使用不包含在任何方法体中的静态代码块(static block )，当类被载入时，静态代码块被执行，且只被执行一次，静态块经常用来进行类属性的初始化。
Ø 类中的静态代码块被自动执行，尽管我们产生了类的多个实例对象，但其中的静态代码块只被执行了一次。当一个程序中用到了其他的类，类是在第一次被使用的时候才被装载，而不是在程序启动时就装载程序中所有可类。
例：
class StaticCode{
static String country;//定义了一个静态的字符串类型的成员变量
static { //定义了一个静态的代码块。
country = "china"; //对静态成员变量进行初始化（赋值）
System.out.println("StaticCode is loading");
}}
class TestStaticCode{
static{ System.out.println("TestStaticCode is loading");}
public static void main(String []args){
System.out.println("begin executing main method");
new StaticCode();
new StaticCode();
}}
（4）单态设计模式：
所谓类的单态设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。
例：
Public class Testsingle
{
private TestSingle(){}//私有的构造函数
private static final TestSingle onlyOne=new TestSingle();
public static TestSingle getTestSingle()
{
return onlyOne;
}
}
我们在外面只能调用TestSingle.getTestSingle()方法获得 TestSingle的对象。
（5）Main方法的语法：
由于java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public，又因为java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static的，该方法接收一个String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数。
例：
public class TestMain
{
public static void main(String []args)
{
for(int i=0;i<args.length;i++)
{
System.out.println(args[i]);
}
}
}
七、内部类
（1）内部类的定义：
在一个类内部定义的类叫做嵌套类，也叫内部类、内置类。
Ø 嵌套类可以直接访问嵌套它的类的成员，包括private成员。
Ø 外部类不能访问内部类的成员。
Ø 如果用static修饰一个内部类，这个类就相当于是一个外部定义的类，所以static的内部类中可声明static成员，但是，非 static的内部类中的成员是不能声明为static的。static的内部类 不能再使用外层封装类的非static的成员变量。
Ø 如果函数的局部变量（函数的形参也是局部变量），内部类的成员变量，外部类的成员变量重名，我们应该按正确方式来明确 指定我们真正要访问的变量。
（2）内部类被外部类引用：
内部类也可以通过创建对象从外部类之外被调用，只要将内部类声明为public即可。
例：
class Outer
{
private int size=10;
public class Inner
{
public void doStuff()
{
System.out.println(++size);
}
}
}
public class TestInner
{
public static void main( String[] args)
{
Outer outer = new Outer();
outer.Inner inner = outer.new Inner();
inner.doStuff();
}
（3）方法中定义的内部类：
Ø 嵌套类并非只能在类里定义，也可以在几个程序块的范围之内定义内部类。例如，在方法中，或甚至在for循环体内部，都可以定义嵌套类 。
Ø 在方法中定义的内部类只能访问方法中的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。
例：
class inOut{
String str=new String("Between");
public void amethod(final int iArgs){
int it315;
class Bicycle {
public void sayHello(){
System.out.println(str);
System.out.println(iArgs);
}
}}
public class TestFinalInner {
public void test(){
final int i=10;
class TestInner{
public void testInner(){
System.out.println("i="+i);//方法中定义的内部类，只能访问方法中final类型的局部变量
}}
TestInner ti=new TestInner();
ti.testInner();
}
public static void main(String[] args) {
// TODO Auto-generated method stub
TestFinalInner tf=new TestFinalInner();
tf.test();}
}
八、JAVA中的文档注释
文档注释以“/**”开始，以“*/”标志结束，相应的信息和批注所对应的位置很重要！ 类的说明应在类定义之前，方法的说明应在方法的定义之前。 批注参数来标记一些特殊的属性及其相应的说明 。
@author<作者姓名>
@version<版本信息>
@param<参数名称><参数说明>
@return<返回值说明>