Java的面向对象基础（没写完）

面向对象的三个基础特性：封装性、继承性、多态性。

Java语言中一个类的实现包括类声明和类体。

类声明语法格式如下：

[public] [abstract|final] class className [extends superclassName] [implements interfaceNameList] {

    //类型
}

class是声明类的关键字，className是自定义的类名，class前面的修饰符public、abstract、final用来声明类，它们可以省略。

superclassName为父类点，可以省略，如果省略，则该类继承Object类，Object类为所有类的根类，所有类都直接或间接继承Object；interfaceNameList是该类实现的接口列表，可以省略，接口列表中的多个接口之间用逗号分隔。

在语法说明中，括号（[]）表示可以省略；竖线（|）表示“或关系”，但是不能同时出现。

声明动物（Aminal）类代码如下：

//Animal.java
public class Animal extends Object {
    //类体
}

上述代码声明了动物（Animal）类，它继承了Object类。继承Object类extends object代码可以省略。

声明类体中成员变量语法格式如下：

class className{

    [public|protected|private] [static] [final] type variableName; //成员变量

}

type是成员变量数据类型，variableName是成员变量名。type前的关键字都是成员变量修饰符，说明如下：

1、public、protected和private修饰符用于封装成员变量。

2、static修饰符用于声明静态变量，所以静态变量也称为“类变量”。

3、final修饰符用于声明变量，该变量不能被修改。

一个声明成员变量示例如下：

//Animal.java
public class Animal extends Object {
    //动物年龄
    int age=1;
    //动物性别
    public boolean sex=false;
    //动物体重
    private double weight=0.0;
}

声明类似中成员方法语法格式如下：

class class{
    [public|protected|private] [static] [final|abstract] [native] [synchronized] type methodName ([paramList]) [throws exceptionList] {
        //方法体
    }
}

type是方法返回值数据类型，methodName是方法名。type前的关键字都是方法修饰符，说明如下：

1、public、protected和private修饰符用于封装方法。

2、static修饰符用于声明静态方法，所有静态方法也称为“类方法”。

3、final|abstract不能同时修饰方法，final修饰的方法不能在子类中补覆盖；abstract用来修饰抽象方法，抽象方法必须在子类中被实现。

4、native修饰的方法，称为“本地方法”，本地方法调用平台本地代码，不能实现跨平台。

5、synchronized修饰的方法是同步的，当多线程方式同步方法时，只能串行地执行，保证线程是安全的。

方法声明中还有（[paramList]）部分，它是方法的参数列表。throws exceptionList是声明抛出异常列表。

声明方法示例：

public class Animal {//extends Object {
    //动物年龄
    int age=1;
    //动物性别
    public boolean sex=false;
    //动物体重
    private double weight=0.0;
    public void eat() {
        //方法体
        return;
    }
    int run() {
        //方法体
        return 10;
    }
    protected int getMaxNumber(int number1, int number2){
        //方法体
        if(number 1>number 2){
            return number1;
        }
        return number2;
    }
}

定义包语法格式如下：

package pkg1[.pkg2[.pkg3...]];

package语句应该放在源文件的第一行，在每个源文件中只能有一个包定义语句，并且package语句适用于所有类型（类、接口、枚举和注释）的文件。

如果在源文件中没有定义包，那么类、接口、枚举和注释类型文件将会被放进一个无名的包时，也称为默认包。

包引入的语法格式如下：

import package1[.package2...](类型名|*);

“包名.类型名”形式只引入具体类型，“包名.*”采用通配符，表示引入这个包下所有的类型。但从编程规范的角度提倡明确引入类型名，即“包名.类型名”形式可以提高程序的可读性。

Java SE的常用包有java.lang、java.io、java.net、java.util、java.text、java.awt和javax.swing。

方法重载示例MethodOverloading.java代码如下 ：

package helloworld;

class MethodOverloading{
	void receive(int i) {
		System.out.println("接受一个int参数");
		System.out.printf("i = "+i);
	}
	void receive(int x, int y) {
		System.out.println("接收两个int参数");
		System.out.printf("x = %d, y= %d \r",x,y);
	}
	int receive(double x, double y) {
		System.out.println("接受两个double参数");
		System.out.printf("x= %f, y=%f \r", x,y);
		return 0;
	}
}

public class helloworld {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MethodOverloading mo= new MethodOverloading();
		//调用void receive(int i)
		mo.receive(1);
		//调用void receive(int x, int y)
		mo.receive(2,3);
		//调用void receive(double x, double y)
		mo.receive(2.0,3.3);		
	}

}

运行结果如下：

接受一个int参数
i = 1接收两个int参数
x = 2, y= 3 
接受两个double参数
x= 2.000000, y=3.300000 

Java面向对象的封装性是通过对成员变量和方法进行访问控制实现的，访问控制分为4个等级：私有、默认、保护和公有。

Java类成员的访问控制

控制等级	同一个类	同一个包	不同包的子类	不同包非子类
私有	Yes
默认	Yes	Yes
保护	Yes	Yes	Yes
公有	Yes	Yes	Yes	Yes

私有级别

私有级别的关键字是private，私有级别的成员变量和方法只能在其所在类的内部自由使用，在其他的类中则不允许直接访问。私有级别限制性最高。

默认级别

默认级别没有关键字，也就是没有访问修饰符，默认级别的成员变量和方法，可以在其所在类内部和同一个包的其他类中被直接访问，但在不同包的类中则不允许直接访问。

DefaultClass.java文件，代码如下：

public class DefaultClass {
    int x;
    public DefaultClass(){
        x=100;
    }
    void printX(){
        System.out.println("Value of x is"+x);
    }
}

HelloWorld.java文件，代码如下：

public class HelloWorld {
    public static void main(String[] args){
        DefaultClass p;
        p=new DefaultClass();
        p.printX();
    }
}

运行结果如下：

错误: 找不到或无法加载主类 HelloWorld
原因: java.lang.ClassNotFoundException: HelloWorld

不知道怎么解决。 很头疼。后来想起来了办法，在同一个文件夹，在这个文件夹必须是HelloWorld，才能运行成功。运行结果如下：

Value of x is 100

保护级别

保护级别的关键字是protected，保护级别在同一包中完全与默认访问级别一样，但是不同包中子类能够继承父类中的protected变量和方法，这就是所谓的保护级别，“保护”就是保护某个类的子类都能继承该类的变量和方法。

ProtectedClass.java文件，代码如下：

public class ProtectedClass {
    protected int x;
    public ProtectedClass(){
        x=100;
    }
    protected void printX(){
        System.out.println("Value Of x is "+x);
    }
}

HelloWorld.java文件，代码如下：

public class HelloWorld {
    public static void main(String[] args){
        ProtectedClass p;
        p=new ProtectedClass();
        p.printX();
    }
}

运行结果如下：

HelloWorld.java:3: 错误: 无法访问ProtectedClass
        ProtectedClass p;
        ^
  错误的源文件: ./ProtectedClass.java
    文件不包含类ProtectedClass
    请删除该文件或确保该文件位于正确的源路径子目录中。

 代码错误，很头疼。不知道怎么解决。第122页。

公有级别

公有级别的关键字是public，公有级别的成员变量和方法可以在任何场合被直接访问，是最宽松的一种访问控制等级。

PublicClass.java文件，代码如下：

public class PublicClass {
    public int x;
    public PublicClass(){
        x=100;
    }
    public void printX(){
        System.out.println("Value Of x is "+x);
    }
}

HelloWorld.java文件，代码如下：

public class HelloWorld {
    public static void main(String[] args){
        PublicClass p;
        p=new PublicClass();
        p.printX();
    }
}

运行结果如下：

Value Of x is 100

静态变量和静态方法

静态代码块

第125页。