java基础读书笔记（三）——面向对象的特征

面向对象的特征

- 封装性：

   封装就是把每个对象的数据（属性）和操作（行为）包装在一个类中。

类的构造方法：

 将成员变量初始化封装起来的方法。构造方法是一种特殊的成员方法。
 （1）构造方法名与类名相同。
 （2）构造方法不返回值，没有返回类型（包括void类型）。
 （3）构造方法总是和new运算符一起被调用。
 （4）构造方法可以重载。即每个类可以有零个或多个构造方法。
 （5）构造方法在创建对象时直接执行，一般显示不能直接调用。
 （6）系统默认未定义构造方法的类中时缺省的空构造方法。

eg：输出指定学生的年龄和性别

public class Student {
    public String Name;
    public int age;
    public char sex;
/**
 * 构造方法，Student前无任何返回类型。
 */
    public Student(String name, int age, char sex) {
        super();
        Name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return Name;
    }
    public int getAge() {
        return age;
    }
    public char getSex() {
        return sex;
    }
    public static void main(String[] args) {
          Student s1 = new Student("Mark", 27, '女');//创建Student类的对象
          Student s2 = new Student("Jackson", 17, '男');
          System.out.println("Mark的年龄："+s1.getAge());//对象成员方法的调用
          System.out.println("Jackson的性别："+s2.getSex());
    }

}

运行结果：

this和super的引用

Java系统默认每个类都缺省的具有null、this、super三个对象的引用变量。
==null==：代表空对象，一般用null来代表未创建的对象。
==this==:指当前对象的引用。
==super==：指对父类的引用。是用来访问父类被隐藏的数据成员;是调用父类中被子类覆盖的方法;是调用父类的构造函数。

eg:this的运用

public class ThisEg {
      private String name;
      private int age;
    public ThisEg(String name, int age) {
        super();  //调用父类（隐藏继承的Object类）的构造函数
        this.setName(name);//用this引用当前对象
this.setAge(age);
        this.print();
    }
    public void setName(String name) {
        this.name = name; //this指明赋值号左边为引用当前对象的成员变量，以免混淆
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void print(){
        System.out.println("Name="+name+";Age="+age);//在此行中并不需要用this,因为并不会导致混淆
    }
    public static void main(String[] args) {
        ThisEg ts = new ThisEg("Yi", 23);
    }
}

运行结果：

eg:super的运用

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 print(){
        System.out.println("Name="+name+";Age="+age);
    }

}
public class SuperEg extends Person{
    /**
     * 覆盖掉父类中的print()方法
     */
      public void print(){
          System.out.println("test:");
          super.print(); //直接调用父类的成员方法
      }
      public static void main(String[] args) {
        SuperEg  se = new SuperEg();
        se.setName("Danniu");
        se.setAge(8);
        se.print();  //调用覆盖后的方法
    }
}

运行结果

类成员访问权限修饰符

修饰符	同一个类	同一个包	子类	所有类
Public	允许访问	允许访问	允许访问	允许访问
protected	允许访问	允许访问	允许访问
缺省的	允许访问	允许访问
private	允许访问

==把重要的数据修饰为private，然后写一个public的函数访问，正好体现了面向对象编程的封装性，是面向对象编程安全性的体现； 子类继承父类，覆盖父类的成员和方法时，修饰符的访问权限不能小于父类。==

- 继承性

 （1）Java语言不支持多继承，但允许一个类实现多个接口。
（2）所有的Java类都直接或间接的继承了Java.lang.Object类。

- 多态性

 1）多态是指同名的不同方法根据发送消息的对象以及方法传送参数的不同，采取不同的行为方式的特性。
2）将一个方法调用同一个方法主体连接到一起就称为“绑定”（binding）
==前期绑定==：（静态绑定）在程序执行前。Java中static和final(private方法属于final)方法是前期绑定。（编译时多态）
==后期绑定==：（动态绑定，dynamic binding）在程序运行时，根据对象的类型进行绑定。（运行时多态）
3）Javazhong 提供两种多态机制：覆盖、重载。

覆盖（Overiding）和重载(Overloading)

两者之间的区别：

覆盖	重载
子类和父类的关系	同一个类内部多个方法间的关系
两个方法间的关系	可能有多个重载方法
相同的方法名和形参表	只能与相同的方法名，不能有相同的形参表
区分方法的是调用它的对象	根据形参来决定调用的是哪个方法
final修饰的方法不能被覆盖	final修饰的方法只能被重载

覆盖：

public class Person {
    String name;

    public void eat(Food d) {
        System.out.println(this.name + "吃" + d.name);

    }
    public  void speak(){
        System.out.println("讲中文！")
    };
}


public class English extends Person{
    public void speak(){
        System.out.println("讲英文！");
    }

}

public class Test {

    public static void main(String[] args) {
        Person p = new Chinese();
        p = new English();
        p.speak();
    }

}

运行结果：

重载:

public class OverloadEg {
    //重载的方法
    int add(int a,int b){
        return (a+b);
    }
//  int add(long a,long b){}   非法重载，long和方法中的int是同一简单类型的参数
    double add(double a,double b){
        return (a+b);
    }

    public static void main(String[] args) {
         int a;
         double b;
         OverloadEg p = new OverloadEg();
         a = p.add(1, 2);
         b = p.add(4, 5);
         System.out.println("a="+a);
         System.out.println("b="+b);
    }
}

运行结果：

运行时多态

 多态（polymorohism）提高了程序的可扩充性。
 （1）通过继承父类对象的引用变量来引用子类对象的方法来实现。

 （2）通过接口类型变量引用实现接口的类对象来实现。

//定义接口Animal
public interface Animal {
   void run();
}
//实现接口Animal的类Cat
public class Cat implements Animal {

    public void run() {
        System.out.println("猫会跑");

    }
}
//实现接口Animal的类Dog
public class Dog implements Animal {

    @Override
    public void run() {
        System.out.println("狗会跳");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Animal a;
        a = new Cat();
        a.run();
        a =new Dog();
        a.run();
    }
}

运行结果：