2010年3月4-6日Java较多

这几天网络有问题，所以今天一起总结出来

类的小结

1，类抽象了所有具有一定共性的实体的共同特称。一个类中，变量用来表示属性，方法用来表示功能，类把数据和对数据的操作封装成一个整体。程序语言中，通过类创建对象。

2，构造函数的作用在于声明类的对象后，为其分配储存单元，即创建实例。

3,不同对象的实例变量将被分配不同的内存空间，所有对象的类变量都分配给相同的一块内存空间。

4，对象是引用型变量。对象调用变量及方法会受到权限的限制，Java通过修饰符public private protected等来说明使用权限，在权限范围内，对象过通过调用方法可以产生一定行为。

5，实例方法只能由对象调用，实例方法既能对类变量操作也能对实例变量操作，类方法既可由对象调用，又可直接由类名调用，而类方法只能对类变量进行操作。

6，包是Java语句中有效管理类的机制。如果类在同一个包中，那么相应对象能访问自己的有好成员，如果类不在同一个包中，那么相应对象只能访问public和protected成员。

 

在程序中，类主要有两个任务；

1，类定义了与其有关的抽象物，我们可以使用类描述真是世界的实体，无论他们有多复杂。

2，类是程序模块化的基础。

在系统构造中尽可能运用人类的自然思维方式，这种设计方法符合我们的思维习惯。

 

类的机制把某些数据成员和方法对外封装起来，以免被不正当的存、取。

 

面向对象技术中，对象的状态用 变量 表示，对象的行为用 方法 表示。

使用一个对象前，必须声明并 new 它。

成员变量在 类 中有效，局部变量只在 方法 中有效。

 

1，构造方法的用途和特点：

创建内存空间，特点，方法名和类名相同，无返回值，void

 

2.举例说明类方法和实例方法，以及类变量和实例变量的区别。

实例方法可以访问实例变量和类变量，类方法只能访问类变量，类变量可以直接被类名调用，实例变量必须由对象调用。同一个类中，类变量公用一块内存。

 

///

g.setFont(new Font("宋体"Font.BOLD,36));

///

 

类的继承性与多态性

class 子类名 extends 父类名

{

 

}

由继承而得到的类，叫做子类或者派生类，被继承的类叫做父类或者超类。

1，Object是包 java.lang中的类

2，类java.long.Object 处于Java开发环境的类的层次的根部，其它所有类，都直接或者间接的继承了它。

3，toString()是Object类中的常用方法，用来返回对象的字符串表示。

 

继承实现了软件的重用。

在子类中，只要声明这个类是从已知的父类继承过来的，这样就可以使用父类的非私有的方法和变量。

Java不支持多重继承，但是支持多重接口，用来实现多重继承的功能。

 

子类的继承性

如果子类和父类在同一个包（文件夹）中，那么子类继承父类除了私有private以外的所有变量和方法，如果子类和父类不在同一个包（文件夹）中，那么子类只能继承父类public和protected的变量和方法。

父类的构造函数不能被继承，它只属于定义它的类。

 

关键字super的使用

super的三种用法：

1，调用父类构造函数

super(参数);

2，调用父类中被重写的方法

super.Method(参数);

3，访问父类被隐藏的成员变量

super.variable;

案例 调用父类构造函数

public class Father

{

        public Father(int x)

        {

                //代码部分

        }

        //代码部分

}

子类

public class Tom extends Father

{

        public Tom()

        {

                super(20);

                /*调用父类构造方法，当创建一个子类对象时，子类构造函数首先，调用并执行父类的构造函数，（显式的或者隐式的），可以创建和初始化类（继承）的父类成员。super必须用在第一句。
                */

        }

}

 

1，Java系统会默认每个类都具有this、super和null三个域，所以任意类中都可以不加说明地直接引用它们，this和super两个域则与继承紧密相连。

2，类方法中不能使用this或super。

3，null代表“空”，是指一个说明都没有的“空”域。在定义一个对象但尚未为其开辟内存空间时，可以指定这个对象为null。

 

类成员的覆盖

若子类的成员变量和父类中的成员变量同名，则我们就说子类覆盖父类的成员变量。访问子类中的同名成员变量时，父类的被隐藏。

 

若子类中定义一个方法，并且方法，名字、返回类型、参数的个数、参数的类型 

和父类的某个方法完全相同，这个父类的方法被隐藏。我们就说我们重写了父类的方法或者叫做覆盖。

 

运行时的多态性，对于重写或者继承的方法。Java运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法。

 

重点：重写父类的方法时，不可以降低方法的访问权限，也就是说，如果父类的权限是public那么子类方法也应该是public 不可以比public权限低

例如

class Father

{

        public  void   one(){}

        protect  void two(){}

        void three(){}

        private void  four(){}     

}

class Sun extends Father

{

        public void one(){}//可以，没有降低访问级别

        protect void one(){}//不可以，降低了访问级别

        public void two(){}  //可以，提升了访问级别

        void protect two(){}//不可以，降低了访问级别

        //应为four是私有的，所以访问不到four

}

 

改写后的方法不能比重写的方法产生更多的例外。（这句话我没弄明白，什么叫更多的例外呢？希望有高手指点）。

 

参数类型的区分度一定要足够，例如不能是同一简单类型的参数，如int与long。
一个类的多个构造函数之间还可以相互调用，这可以通过关键字this来实现。需要注意的是，这个调用语名必须是整个构造函数的第一个可执行语句。

 

类的多态：

所谓多态，就是一个对象有多种形态，简单的说，同一个名字的方法，因为参数不同，实现不同的功能。

比如说 自定义一个比大小的方法

……

{

        public String sort(int x,int y)

        {

                if(x>y)

                        return x+" "+y;

                else

                        return y+" "+x;

        }

        public String sort(int x,int y,int z)

        {

                int swap;

                if(x<y)

                        {swap=x;x=y;y=swap;}

                if(x<z)

                        {swap=x;x=z;z=swap;}

                if(y<z)

                        {swap=y;y=z;z=swap;}

                return x+" "+y+" "+z;

        }

}

这是一段多态的实例，同样是方法名sort()输入2个数字和输入3个数字执行的却是不同的方法。在实际应用中非常的方便。

 

构造函数的重载

class OverLoadDemo

{

        OverLoadDemo()

        {

                OverLoadDemo();

                OverLoadDemo(String str);

                OverLoadDemo(String str1,String str2);

        }

}

public class A

{

        public static void main(String[] args)

        {

                OverLoadDemo strdemo1 = new OverLoadDemo();

                OverLoadDemo strdemo2 = new OverLoadDemo("Java");

                OverLoadDemo strdemo3 = new OverLoadDemo("Java","Program");

        }

}

 

多态的构造方法，可以提供多种初始化对象的能力，使程序员可以根据自己需要来初始化对象。