学习java很久了，现在我们应该对面向对象这个概念有一定程度的理解了。面向对象的编程思想，从名词本身来看我们就会明白，它是一种思想，是一种对于每一位java编程人员由始至终都应该去不断学习、不断体会、不断深入的一个概念。今天我主要总结例化一下面向对象的三大基本特征——封装、继承、多态。

   我们一起来学习吧。C_0012.gif


一.封装

  1. 简单的来说，封装就是把属性私有化，外部不能直接访问，但可以通过对外提供的公有的get和set方法让外部能访问内部的私有属性。下面以老师类和学生类为例来说明问题：

package oo;
/*
 * 老师类
 */
public class Teacher {
    //属性全部私有化
    private String name;
    private int id;
    private Student student;
    public String getName() {
        return name;
    }
    //外部可以通过get和set方法访问私有属性
    public void setName(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setStudent(Student student){
        this.student=student;
    }
    //如果不提供getStudent方法，则外部就不能访问老师的学生信息
    public Student getStudent(){
        return this.student;
    }
}
package oo;
/*
 * 学生类
 */
public class Student {
    private int id;
    private String name;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
package oo;
/*
 * 测试类，当做外部来访问老师类的私有信息
 */
public class Test {
    public static void main(String[] args) {
        Teacher teacher=new Teacher();
        Student student=new Student();
        teacher.setId(1);
        teacher.setName("王老师");
        student.setId(1);
        student.setName("张菲");
        teacher.setStudent(student);
        System.out.println(teacher.getId()+" "+teacher.getName()+
                " "+teacher.getStudent().getName());
        //输出结果：1 王老师 张菲
    }
}


  2.上面的例子是封装的基本应用之处，当然，封装还有一个好处：当有一段实现一定功能的代码会有多处用到它时，我们就会用到封装，实现代码的复用，省时间省空间，提高编程效率，见下面的例子：

.  （1）Teacher.java中添加代码：

...
public void stuMessage(){
        System.out.println("这位老师的学生信息是：");
        System.out.println(this.getStudent().getId()+" "+this.getStudent().getName());
    }
...

  （2）Test.java中添加代码：

...
//调用了老师类的公有方法来查看学生信息
        teacher.stuMessage();
...

  当程序需要多次查看老师的学生信息时，就可以直接调用老师类的公有方法stuMessage来访问了。


二.继承

  先给出两个类：Person和Student，分别具有的属性和方法如下

package oo;
/*
 * 人类
 */
public class Person {
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void getInfo(){
        System.out.println(this.name+" "+this.age);
    }
}
package oo;
/*
 * 学生类，具有人的全部属性和方法
 */
public class Student {
    private int age;
    private String name;
    private String school;
    public void setAge(int age) {
        this.age = age;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void getInfo(){
        System.out.println(this.name+" "+this.age+" "+this.school);
    }
    public void study(){
        System.out.println("我是好学生，我正在学习！");
    }
}

   

   简单的看一下上面的例子，我们就会发现由于学生也是人类，产生了很多重复缀余的代码，OK，用到继承的时刻到了，我们就看看extends的用处吧：


   1.通过继承可以简化定义：

package oo;
/*
 * 通过继承可以简化定义
 */
public class Test {
    public static void main(String[] args) {
        Person p1=new Person();
        //父类Person的对象p1只能访问自己的成员
        p1.setName("人");
        p1.setAge(0);
        p1.getInfo();
        /*p1.setSchool("林大");
        p1.study(); 错误，父类不能访问子类成员*/
                                                                                                                                                                                                                                                                                                                                       
        Student s1=new Student();
        //子类Student的对象可以访问父类的成员
        s1.setName("张菲");
        s1.setAge(20);
        s1.getInfo();
        //子类对象访问自己的成员(这是不用说的)
        s1.setSchool("林大");
        s1.getSchool();
        s1.study();
                                                                                                                                                                                                                                                                                                                                       
        //父类对象可以向下转型（多态初步）
        Person p=new Student();
        p.setName("王剑");
        p.setAge(22);
        p.getInfo();
        //此时访问子类成员时需要类型转换
        ((Student)p).setSchool("工大");
        ((Student)p).getSchool();
        ((Student)p).study();
                                                                                                                                                                                                                                                                                                                                        
        //Student s=new Person();错误，子类对象不能向上转型
    }
}


  2.java只支持单继承不支持多继承，下面例子足以说明：


package oo;
public class ExtendsTest{
    public static void main(String[] args) {
        new C().printA();
        System.out.println("----------------");
        new C().printB();
        System.out.println("----------------");
        new C().printC();
    }
}
class  A{
    public void printA(){
        System.out.println("A被调用了");
    }
}
class B extends A{
    public void printB(){
        printA();
        System.out.println("B也被调用了");
    }
}
class C extends B{
    public void printC(){
        printB();
        System.out.println("C也被调用了");
    }
}

   输出结果：

A被调用了
----------------
A被调用了
B也被调用了
----------------
A被调用了
B也被调用了
C也被调用了

   

   3.子类可以继承父类的所有成员变量和成员方法，但是不能继承父类的构造方法；

     （1）在子类的构造方法中可以使用super(参数列表)的方式来调用父类的构造方法；

     （2）如果子类的构造方法中没有显式地调用父类构造方法，也没有使用this 关键字调用重载的其它构造方法，则在产生子类的实例对象时，系统默认调用父类无参数的构造方法。


class A{
    private int id;
    private String name;
    public A(){
                                                                                                                                                                                                                
    }
    public A(String name,int id){
        this.name=name;
        this.id=id;
    }
}
class B extends A{
    private int age;
    public B(){
        super();
    }
    public B(String name,int id,int age){
        super(name,id);
        this.age=age;
    }
}


三.多态

package day04.Poly;
/*
 * 父类，宠物类
 */
public class Pet {
    private String name;
    private int age;   
    public Pet(){
    }  
    public Pet(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return this.name+" "+this.age;
        //重写了Object的toString方法
    }
    public String toString(String str){
        return str;
        //重载了Object的toString方法
    }
                                                                                                                                                                                                      
    public void what(){
        System.out.println("Pet:我是什么宠物？");
    }
    public static void test(){
        System.out.println("I am a Father Test");
    }
    //用于宠物类测试
    public static void main(String[] args) {
        Pet moren=new Pet();
        System.out.println(moren.hashCode());
        System.out.println(moren.getClass());
        System.out.println(moren.toString());
        //重写之后输出的就不是物理地址了
        Pet mo=new Pet("什么",20);
        System.out.println(mo.toString());
        System.out.println(mo.toString("有木有"));
                                                                                                                                                                                                          
                                                                                                                                                                                                          
        }
}


package day04.Poly;
/*
 * 子类，狗狗类
 */
public class Dog extends Pet{
    private String color;
    private String kind;
    public Dog(){
                                                                                                                                                                                                      
    }
    public Dog(String name,int age,String color, String kind) {
        super(name,age);
        this.color = color;
        this.kind = kind;
    }
    public void what(){
        System.out.println("Dog:我是一只可爱的狗狗。");
    }
    public void heihei(){
        System.out.println("嘿嘿");
    }
                                                                                                                                                                                                  
    public static void test(){
        System.out.println("I am a Dog Test");
    }
}
package day04.Poly;
/*
 * 子类，猫咪类
 */
public class Cat extends Pet{
    public Cat(){
                                                                                                                                                                                                    
    }
    public void what(){
        System.out.println("Cat:我是一只淘气的小花猫。");
    }
    public static void test(){
        System.out.println("I am a Cat Test");
    }
}
package day04.Poly;
/*
 * 测试类
 */
public class Text {
    public static void main(String[] args) {
        Pet pet1=new Pet();
        Dog dog1=new Dog();
        Cat cat1=new Cat();
                                                                                                                                                                                                  
        //pet.what();
        //pet.heihei();多态时
        /*pet1.what();
        dog1.what();
        cat1.what();*/
        Pet pet=new Cat();//强制类型转换时并没有创建新的对象（父类到子类的转换不是自动的）
        if(pet instanceof Dog){
            Dog dog=(Dog)pet;
            dog.what();
            dog.test();
        }else if(pet instanceof Cat){
            Cat cat=(Cat)pet;
            cat.what();
            cat.test();
        }
                                                                                                                                                                                                  
        Pet p=new Dog();
        if(p instanceof Dog){
            Dog dog=(Dog)p;
            dog.what();
            dog.test();
        }else if(p instanceof Cat){
            Cat cat=(Cat)p;
            cat.what();
            cat.test();
        }
                                                                                                                                                                                                  
        System.out.println();
        System.out.println("以下证明：静态方法没有多太");
        dog1.test();//一下这三句是正常的子类对象调用自己的static方法
        cat1.test();
        pet1.test();
                                                                                                                                                                                                  
                                                                                                                                                                                                  
        Pet.test();//pet.test();p.test();这两句与Pet.test等价，即可以看出static方法没用多太只有重写
                                                                                                                                                                                                  
    }
}



嗯嗯 ，就写到这里啦，我想应该很好理解吧，谢谢大家的支持，明天见C_0019.gif