这章就进入了对Java面向对象的学习，有了前面的铺垫，我想大家对Java已经有了一定的了解，这章我会为大家讲述关于类的相关知识。

1.1 类的定义

1.类声明

格式如下：
<修饰符> class <类名> exend<父类> implement<接口名>
几点说明：
（1）类定义修饰符。
类定义修饰符为类声明中可选部分；如定义性质（包括abstract、final）和访问权限（如public或默认），后续我会讲解。
（2）extend。
extend为类声明中可选部分，用于说明类的父类；一般形式为extend<父类>。
（3）implement。
implement为类声明中可选部分，用于说明类的接口。

2.类主体

类主体基本格式如下：
<类声明>{
<成员变量的声明>
<成员方法的声明及实现>
}
注意；Java里面没有独立的函数，所有的函数都是作为类方法定义的。

请看下面类声明与定义的源代码：

class point{
    int x;
    int y;
    void init (init int ix,int iy){
        x=ix;
        y=iy;
    }
}

上面是一个对点赋值的类声明，这里可以清楚的看出类成员是x与y，我们用类方法init（）来对点进行赋值；

有的博友可能到现在还没有明白类的成员变量和成员方法是啥，我们下面开始讲解；

3.成员变量

定义格式一般如下：
[ 变量修饰符] <变量类型> <变量名>

这里注意，在java程序内，成员变量是唯一的，但是允许成员变量的名字与成员方法相同，不同类之间也可以出现相同的成员变量名，由于他们的作业区域不同，或者可以通过访问权限来加以区别。

4.成员方法

格式如下：
[方法修饰符] <返回值类型> <方法名> ([ 参数列表 ])
{
方法体}

这里的方法体里面包括了对代码的实现，在里面可以定义局部变量，但作用域仅局限于方法内。

5.构造方法的几点说明：

在定义构造方法时需要注意以下几点。
(1)构造方法没有返回值类型,甚至没有 void，其修饰符只能是public、private、 protected中的任一个。
(2）构造方法不能从父类中继承。
(3）系统默认提供无参构造方法，该方法根据成员变量的类型进行初始化。
(4)构造方法可以重载 ，一个类可以有任意多个构造方法。
（5）构造方法不能直接通过方法名引用，必须通过new 运算符。
（6)在构造方法中以调当前类和其父类的另一个构造方法，但必须是方法体的第一句。使用当前类的构造方法用 this来引用，使用其父类的构造方法用 super来引用。

1.2 类的使用

1.对象声明

格式如下：
类名 对象名；
举例：
class a；

2.对象创建

在Java里，对象的声明并没有分配对象，因而我们要通过new运算符来将对象实例化。
这里我们有两种方法进行对对象的初始化；
（1）先声明，后赋值；
（2）声明与赋值同时进行；
第二种方法用的较多,它的格式如下:
类名 对象名=new 类名（）；

有时候为了方便，我们会利用数组来进行多个对象的赋值；

3.对象使用

对象可以通过“.”运算符来实现对自己的成员变量和方法的调用。

4.对象释放

当对象不再使用时，java会自动进行垃圾回收工作，简化了程序的出错。

1.3 方法重载

方法重载就是在一个类中，多个方法，他们的方法名相同，但参数的个数或者类型不同。方法的返回值不作为判断依据。

二、访问权限的控制符

2.1 public 、protected与private

1.public：

public类型可以被任意类和方法访问与引用，这里需要注意，Java的文件名应与public后面的类名一致。

2.protected：

具有protected属性的类成员可以被本类、本包中的其他类和其他包中子类访问，访问性低于public，高于默认。

3.private：

用private修饰符只能被该类的成员变量或者方法来访问和修改，而不能被任何其他类获取引用（包括该类的子类）。

2.2 默认

如果在定义类、接口、成员变量、成员方法没有指定访问属性时，则此时访问属性为默认权限。只能被本类和同一个包中的其他类、接口和成员方法引用，因此默认权限也被称为包权限。

下面表格对上述的总结：

2.3 getInfo和setInfo

出于系统设计安全考虑，将成员属性定义为private形式保护起来，而将类的成员方法定义为public形式对外公开，这是类封装性的体现。一般来说，类中应提供get方法（获取private的成员变量值）和set方法（修改private的变量值），以便其它类操作该类private成员变量。

3.1 类的继承

格式如下：
class 子类名 extends 父类名 [implement<接口名>] {
}

Java语言通过使用关键字 extends来实现类的继承，如果类定义时没有使用extends关键字，则默认该类的父类是java.lang.Object类。该类是 Java预定义的所有类的父类，出现在层次结构的最上层。Object类包含了所有Java的公共属性,其中定义的属性可以被任何类使用、继承或修改。

注意：Java里面不支持多继承，只支持单继承。

3.2 super的使用

子类在继承父类时,可能会出现变量隐藏、方法覆盖 ( overriding）等现象。变量隐藏指子类的成员变量与父类成员同名时，父类的成员变量被隐藏。方法覆盖指子类的方法与父类的方法相同,方法的返回值类型、入口参数的数目类型、顺序均相同,只是方法实现的功能不同，此时父类的方法被覆盖。如果子类需要调用或访问父类被隐藏的变量或被覆盖的方法,可以使super关键字实现。

看一段代码：

public class text{
	public static void main(String[] args){
		B b=new B();
		b.upload();
	}
}
	class A{
		public void upload(){
			//上传文件的100行代码
		}
	}
	class B extends A{
		public void upload(){
			super.upload();//用super关键字调用父类的上传文件100行逻辑代码
			//修改文件名的1行代码
		}
	}

这里注意，有三种情况可以用关键字super：
（1）用来访问父类中覆盖的方法；
（2）用来访问父类被覆盖的变量；
（3）用来调用父类的构造方法。

3.3对象类型转换

父类有的方法和属性，子类都有。因此，Java中的子类对象可以向上赋值给父类对象，即上转型对象，当然也允许父类对象的引用指向子类。

举例：假设subclass是子类，而superclass是父类。
superclass superclass=new suclass（）；//父类引用指向子类

反过来，子类指向父类时，可能会出现错误，因为子类具有的信息，而父类不一定有。
suclass suclass =new sucalss（）；//子类的引用指向父类

几点关于上转型对象的说明：
（1）不能操作子类新增加的成员变量和成员方法。
（2）可以代替子类对象调用子类重写的实例方法。
（3）可以调用子类继承的成员变量和隐藏的成员变量。

四、多态性

4.1方法重载与方法覆盖

方法重载（overloading）与方法覆盖（overriding）是实现多态性的基本手段,但两者的机制不同。方法重载是指一个类中可以有多个方法具有相同的名字,但这些方法的参数不相同。参数不同具体体现为参数的个数不同，或者是参数的类型不同。方法覆盖是指子类的方法名与父类的方法名完全相同，并且返回值类型、入口参数的数目、类型均相同，即在子类中重新改写了父类的同名方法。Java根据实际参数的个数和类型来选择调用合适的方法，这样就能使用相同的方法名实现不同的功能体现了多态性。

4.2运行时多态性

Java的多态性是在执行阶段，而不是在编译阶段。
来看一个经典的例子：

public class A {
    public String show(D obj) {
        return ("A and D");
    }
 
    public String show(A obj) {
        System.out.println((this instanceof A) + "A this instanceof A");
        System.out.println((this instanceof B) + "A this instanceof B");
        return ("A and A");
    }
 
 
}
 
class B extends A{
    public String show(B obj){
        return ("B and B");
    }
 
    public String show(A obj){
        System.out.println((this instanceof A) + "B this instanceof A");
        System.out.println((this instanceof B) + "B this instanceof B");
        return ("B and A");
    }
}
 
class C extends B{
 
}
 
class D extends B{
 
}
 
class Test {
    public static void main(String[] args) {
        A a1 = new A();
        A a2 = new B();
        B b = new B();
        C c = new C();
        D d = new D();
 
        System.out.println("1--" + a1.show(b));
        System.out.println("2--" + a1.show(c));
        System.out.println("3--" + a1.show(d));
        System.out.println("4--" + a2.show(b));
        System.out.println("5--" + a2.show(c));
        System.out.println("6--" + a2.show(d));
        System.out.println("7--" + b.show(b));
        System.out.println("8--" + b.show(c));
        System.out.println("9--" + b.show(d));
    }
}

运行结果：

输出结果
trueA this instanceof A
falseA this instanceof B
1--A and A
2--A and C
3--A and D
trueB this instanceof A
trueB this instanceof B
4--B and A
5--A and C
6--A and D
7--B and B
8--A and C
9--A and D

上面的代码可以清楚看出多态性的运行。

五、非访问控制符

在类定义中，除了可以用访问属性来修饰成员变量和方法，还可以用static、final、abstract等说明成员变量或方法的特性。

static可以用来修饰成员变量与方法，分别被称为类变量（静态变量）和类方法（静态方法）。

1.类变量

在生成每个类的实例变量时，Java 运行系统为每个对象的实例变量分配一个内存空间，实例变量指向该内存空间，不同的实例变量占用不同的内存区域。对于类变量来说，Java 运行系统为其分配公共的存储空间，该类的每个实例对象 共享 同一类变量的存储空间。因此，每个对象对类变量的修改都会影响其他实例对象。

几点说明：
（1）类变量可以不用对象访问，直接通过类名访问。
（2）任何一个对象对类变量的修改都会影响其他实例对象。

2.类方法

声明为static 的方法称为类方法(或称静态方法)，与此相对，没有static修饰的成员方法则为实例方法。类方法的本质是该方法属于整个类，而不是属于某个实例。调用类方法时可以不创建实例，直接通过类名调用。

类方法的使用具有以下特点。
(1)类方法可以通过类名直接调用，而不需要创建实例对象。
(2)类方法属于整个类，被调用时可能还没有创建任何对象实例，因此类方法内只可以访问类变量，而不能直接访问实例变量和实例方法。
(3)类方法中不能使用this关键字，因为静态方法不属于任何一个实例（类方法里面没有this指针）。

为了更好的组织类，Java提供了包机制。包是类的容器，Java中的包一般均包含相关的类。

6.1 Java的名字空间

Java注意解决名字空间的冲突问题。没有全局的方法，也没有全局的变量，所有的变量和方法都是在类中定义，且是类的重要组成部分，每个类又是包的一部分。 因此每个Java变量或方法都可以用全限定的名字表示，包括包名、类名、域名3部分，之间用“.”分隔。

Java编译器将Java程序的每个类的编译代码(即字节码)放在不同的文件中，这些编译代码的文件名与类同名，但要加上扩展名( class)。因此一个包含有多个类定义的源文件编译后有多个.class文件。

Java源代码的扩展名一般为java, 其中包括一个或多个类定义。如果在Java文件中有多个类定义，则只能有一个类可以定义为public, 并且这个类的名字必须与程序的源代码名(去掉扩展名)一致。

6.2 包的定义与引入

1.包的定义

我们可以使用package来指明类是属于哪个具体的包。
定义如下：
package pkg1[.pkg2.[pkg3…] ];

这里注意，包名与文件夹的目录是一致的。

2.包的引入

当使用其他包内的类时，需要在程序首行使用import语句。
如下：
import pkg1[.pkg2.[pkg3…] ];

import语句只用来将类中其他包中的类引入到当前空间内。

6.3 JDK提供的主要包

1、java.lang
包含一些Java语言的核心类，如String，Math，Integer，System和Thread，提供常用功能。
2、java.awt
包含了构成抽象窗口工具类（abstract，Windows，tookits）的多个类，这些类被用来构建和管理应用程序的图形用户界面。
3、java.net
包含执行与网络相关的操作的类。
4、java.io
包含能提供多种输入/输出功能的类。
5、java.util
包含一些实用工具类，如定义系统特性，使用与日期日历相关的函数。

上面即为本章大概内容，若有问题，请指正。
也欢迎大家来讨论疑惑。