继承、多态、封装

       从写第一篇技术博客到现在已经很长时间了，这段时间也一直在学习，但一直没能做好技术总结这件事。现在把继承与接口这部分的内容做一个总结：

 

一、面向对象编程思想的三大特点是什么？

1、 继承：继承是指一个类是从另一个类派生而来的，派生类自动具有了被继承类的所有特性。其中，被继承的类叫做父类、基类，继承父类的类叫做子类、派生类或者超类。

2、 多态：多态是指一个东西，不同的情况下呈现出不同的状态，实现不同的功能。静态多态的主要实现形式有函数重载、继承和方法重写，动态多态的理论基础是父类引用可以指向子类对象(即自动转型)。

3、 封装：封装是指隐藏对象的属性及实现细节，对外仅提供接口可见。封装实现了信息隐藏，有利于软件复用。封装使用主要是通过访问控制符public、protected、private和default。

 

二、继承的语法格式是？子类能继承到父类的哪些方法和属性？

java的继承关键字是：extends

       格式：

       public class 子类名 extends 父类名 ｛

       }

       子类又可以叫做超类。

       父类又可以叫做基类。

       java中类只能继承一个父类。类的继承是单继承。

 

1.子类和父类在同一个包下：

              public、protected、default的属性和普通方法能被子类继承到，并且直接通过对象名就可以使用。

              私有的属性和私有方法不能被子类继承。

              构造方法也不能被子类继承。

             

2.子类和父类不在同一个包下：

              公有的属性和普通方法能被子类继承到，并且直接通过对象名就可以调用。

这里注意：不同包下protected的属性和方法是可以被继承的（此处原来写错了，多谢一楼大神指点）

代码验证如下：

这是A类和还有包名

package cn.netjava.lesson04;

publicclass A {

       publicintm=888;

       protectedintn=999;

}

这个是B类和包名，引入了A类的包名

package 练习;

import cn.netjava.lesson04.A;

publicclass B extends A{

 

       publicstaticvoid main(String[] args) {

              B a =new B();

              System.out.println("m是："+a.m+"n是："+a.n);//这里是不报错的

       }

}

 

三、多态的一些实现方式有什么东东？

多态是由java的方法重载，继承，方法重写，自动转型等技术的组合。

1.  方法重写(overwrite)

       要实现方法重写必须满足的条件是：

              方法的访问修饰符，方法返回值类型，方法名，方法所带的参数个数，参数类型和参数的顺序都必须要和父类的完全相同。

       当实现方法重写后：

              实例化的对象是子类的对象时，那么会优先调用子类中的方法，如果子类中没有这个方法，那么则调用父类的方法

2.   方法重载(overload)

在一个类中，定义多个同名，但参数类型和数量不同的方法，叫做方法的重载。

下面以构造函数做一举例说明：

这是A类

publicclass A {

       public String x = null;

       publicinty = 0;

       public A(String x, int y) {

              this.x = x;

              this.y = y;

              System.out.println("构造函数中传入了一个字符串和整型数据");

       }

       public A(String x) {

              this.x = x;

              System.out.println("构造函数中传入了一个字符串");

       }

       public A() {

              System.out.println("构造函数中什么都没有");

       }

}

这是B类

publicclass B extends A{

       publicstaticvoid main(String[] args) {     

              A a =new A();

              System.out.println("x是"+a.x+"\ty是"+a.y);

              A b =new A("我爱你");

              System.out.println("x是"+b.x+"\ty是"+b.y);

              A c =new A("我爱你",520);

              System.out.println("x是"+c.x+"\ty是"+c.y);

       }

}

结果是：

构造函数中什么都没有

x是null     y是0

构造函数中传入了一个字符串

x是我爱你 y是0

构造函数中传入了一个字符串和整型数据

x是我爱你 y是520

 

3.  自动转型

换句话讲，可以这么解释通，即：父类引用可以指向子类对象。可以延伸到以下两个方面：

      1.   函数传入的形参可以是父类类型，实际传入的可以是子类对象

代码演示如下

publicclass Main{

       publicstaticvoid fun(Dialog dialog){

              dialog.show();

       }

       publicstaticvoid main(String[] args){

              fun(new FontDialog());

       }

}

       2.    函数的返回类型是父类类型，实际返回的可以是子类对象

代码演示如下

publicclass Main{

       publicstatic Dialog fun(){

              returnnew FontDialog();

       }

       publicstaticvoid main(String[] args){

              Dialog dialog = fun();

       }

}

       实现自动转型的条件：必须要存在继承关系。

 

四、接口和抽象类的一些东西…

接口的定义

接口是面向对象编程中的又一重要概念，接口只定义提供什么功能，而不定义功能的具体实现。这在程序设计中非常有帮助。

       定义接口的关键字是interface

       格式：

       public interface 接口名 extends 接口名,... {//接口也可以通过extends继承接口

              //常量,常量的值是不能被改变

              public static final 数据类型 常量名 = 值;//这三个关键字都是默认的

              //抽象方法

              public 返回值数据类型 方法名(数据类型 参数名,...);

       }

       注意：1.接口中默认的访问修饰符是public

                2.接口是不能实例化对象的。

 

       降低程序的高耦合低内聚,即:使程序 “低耦合、高内聚”

      

接口的实现

       实现接口的关键字是implements

       格式

       public class 类名 extends 类或抽象类 implements 接口名,... {

              //必须要实现接口中所有的抽象方法。

       }

       类可以继承类，再去实现接口吗？  可以的

 

抽象类的定义和继承

       定义的关键字是abstract class

       继承的关键字是extends

       格式：

       public abstract class 抽象类名 extends 类或抽象类 implements 接口,... {

              //类中任何的方法和属性都可以在抽象类中定义。

              //接口中的常量和抽象方法也可以在抽象类中定义。但是抽象方法的格式稍有不同，

              public abstract 返回值数据类型 方法名(数据类型 参数名,...);

       }

       抽象类就是介于类和接口的一中特殊类。

抽象类至少包含一个抽象方法。

       抽象类也不能实例化对象。

       抽象函数必须被重写，除非子类也是抽象函数。

抽象类中可以含有普通函数。

抽象了介于类和接口之间，可以有实现的，也可以有未实现的方法，常用作“适配器”，这样我们便没必要实现接口中所有的方法了，只需取出所需要的就好了一个抽象类和接口的典型应用是MouseAdapter和MouseListener。

 

五、内部类和匿名内部类是神马东东？

内部类是指在类的内部嵌套定义的类。内部类本身的结构同普通类没什么区别，只不过是定义的位置是在另一个类的内部。内部类可以被修饰成为static属性，这在普通类是不行的。

代码示例如下：

publicclass Outer {              //定义外部类Outer

       staticclass Inner{             //定义内部类Inner

              staticintx = 0;            //定义内部类static成员变量x

              staticvoid test(){         //定义内部类static成员方法test

                     System.out.println("test");

              }

       }

       publicstaticvoid main(String[] args) {

              System.out.println(Outer.Inner.x);//打印内部类Inner的static变量x

              Outer.Inner.test();                       //打印内部类Inner的static方法test

       }

}

结果如下：

      0

      test

 

定义的内部类同样可以被外部引用。内部类可以只定义类体，没有名称，这就是匿名内部类。匿名内部类没有类名，直接用new关键字创建对象，后面｛｝部分为匿名内部类的类体。

类名（接口名） 对象名 = new 类名（接口名）｛

接口中必须要实现的方法

｝；

 

六、包

关键字：package，用法：package PackageName包名是当前源文件下的目录名称。在编写程序时，报名必须写在类文件的最上面。

使用包：

1. 包名加类名

2. Import 导入

3. 静态导入（在导入的对象前加static修饰符）使用了静态导入后，可以直接使用导入类中的变量，不必要采用“类名+.“的方式了。

 

第二篇就写这部分内容，下一篇将对常用的几个关键字进行梳理。

 

2012年8.3日凌晨写于寝室

评论

1 楼 .Bingle 2012-11-03  

引用

2.子类和父类不在同一个包下：
              公有的属性和普通方法能被子类继承到，并且直接通过对象名就可以调用。
这里注意：不同包下protected的属性和方法是不可以被继承的。
代码验证如下：
这是A类和还有包名
package cn.netjava.lesson04;
public class A {
       public int m=888;
       protected int n=999;
}
这个是B类和包名，引入了A类的包名
package 练习;
import cn.netjava.lesson04.A;
public class B extends A{

       public static void main(String[] args) {
              A a =new A();
              System.out.println("m是："+a.m+"n是："+a.n); //结果显示n要变为public才可
       }
}

这里有问题，不同包下Protected的属性和方法是可以被继承的，代码验证中应使用子类B而非父类A