Java笔记07-面向对象

简介

        《Java编程思想》中提到“万物皆为对象”的概念。它将对象视为一种奇特的变量，它除了可以存储数据之外还可以对它自身进行操作。它能够直接反映现实生活中的事物，例如人、车、小鸟等，将其表示为程序中的对象。每个对象都具有各自的状态特征（也可以称为属性）及行为特征(方法)，java就是通过对象之间行为的交互来解决问题的。

        面向对象说到底是一种思想,是一种思考方式,一种编程套路>

面向对象三大特征

1.封装

        封装的两层含义:一层含义是把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个不可分割的独立单元(即对象)中；另一层含义指“信息隐藏”，把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知晓，或只允许使用对象的功能，而尽可能隐藏对象的功能实现细节。

步骤

• 定义与属性存取相关的方法
• 使用权限修饰符
  • 使用private作用在属性上，关闭直接访问的入口
  • 使用public作用在方法上，提供调用的入口

        在属性私有化后，我们需要通过方法来获取属性的值以及对属性值进行修改。避免直接对属性进行修改，由于有了方法结构，我们就可以对存入的数据进行判断，对不符合逻辑的数据进行处理。

class Person{
    // 使用private声明属性
    private String name;
    private int age;

    // 使用public声明方法，作为操作属性的入口
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    public void setAge(int age){
        // 如有需要，可以在方法中可以自定义其他逻辑
        this.age= age;
    }
    public double getAge(){
        return this.age;
    }
}

优点

• 拒绝直接调用声明字段，保护内部数据，更安全
• 重复调用，避免代码冗余，程序编写效率高
• “高内聚”：封装细节，便于修改内部代码，提高可维护性
• “低耦合”：简化外部调用，便于调用者使用，便于扩展和协作

2.继承

        在现实生活中，继承一般指的是子女继承父辈的财产。在程序中，继承描述的是事物之间的所属关系，通过继承可以使多种事物之间形成一种关系体系。例如猫和狗都属于动物，程序中便可以描述为猫和狗继承自动物。

        在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类所有可继承的属性和方法。在程序中，如果想声明一个类继承另一个类，需要使用extends关键字。

        通过 extends 关键字让类与类之间产生继承关系。

        

class 父类{
    ...       //成员变量、成员方法
}
class 子类 extends 父类{
    ...       //类体
}

注意

• 子类可以直接访问父类中的非私有的属性和行为。
• 子类无法继承父类中私有的内容。
• 父类是子类的共性不断向上抽取而来的。
• 子类不能选择性继承父类；
• Java不支持多重继承，但一个类可以实现多个接口，从而克服单继承的缺点；
• 构造方法不会被子类继承，但可以从子类中调用父类的构造方法。

特点

1．在Java中，类只支持单继承，不允许多重继承，也就是说一个类只能有一个直接父类，例如下面这种情况是不合法的。

class 类1{}
class 类2{}
class 类3 extends 类1，类2{}

2．多个类可以继承一个父类，例如下面这种情况是允许的。

class 类1{}
class 类2 extends 类1{}
class 类3 extends 类1{}

3．在Java中，多层继承是可以的，即一个类的父类可以再去继承另外的父类，例如类2继承自类1，而类3又可以去继承类2，这时，类3也可称作类1的子类。例如下面这种情况是允许的。

class 类1{}
class 类2 extends 类1{}
class 类3 extends 类2{}

4．在Java中，子类和父类是一种相对概念，也就是说一个类是某个类父类的同时，也可以是另一个类的子类。例如上面的示例中，类2是类1的子类，同时又是类3的父类。

重写

        在继承关系中，子类会自动继承父类中定义的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。需要注意的是，在子类中重写的方法需要和父类被重写的方法具有相同的方法名、参数列表以及返回值类型。

public class Fu {
    public String method(){
        System.out.println("父类重名方法执行");
    }
}
public class Zi extends Fu {
    @Override
    public Object method(){  //范围：Object > String 报错
        System.out.println("子类重名方法执行");
    }
}

 注意

• 父类中的私有方法不可以被重写

• 父类为static的方法无法重写

• 重写时，子类方法权限一定要大于等于父类方法权限，子类方法返回值一定要小于等于父类方法返回值范围。

• 重写的方法具有与其所重写的方法相同的名称、参数数量。

super关键字

        当子类重写父类的方法后，子类对象将无法访问父类被重写的方法，为了解决这个问题，在Java中专门提供了一个super关键字用于访问父类的成员，可以访问父类的成员变量、成员方法和构造方法。

class Fu{
   private int num = 4;
 
   public int getNum(){
       return num ;
   }
}
 
class Zi extends Fu{
   private int num = 5;
 
   void show(){
       System.out.println(this.num + "..." + super.getNum());
   }
}
 
class ExtendDemo{
   public static void main(String[] args){
       Zi z = new Zi();
       z.show();
   }
}

使用super调用父类的无参数构造方法/有参数构造方法

子类不继承其父类的构造方法。

• 当使用无参数的super()时，父类的无参数构造方法就会被调用；
• 当使用带有参数的super()方法时，父类的有参数构造方法就会被调用。

注意

• 如果要初始化父类中的字段，可以在子类的构造方法中通过关键字super调用父类的构造方法；
• 对父类的构造放的调用必须放在子类构造方法的第一行；
• 如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器；
• 如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表；
• 子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）
   

3.多态

        多态指的是同一个行为具有多个不同表现形式或形态的能力。Java中根据时期多态可分为编译时多态和运行时多态。

编译时多态（在编译时期绑定代码 体现形式---重载）

运行时多态（在运行时期绑定代码 体现形式---重写、向上造型---前提是继承）

向上造型

        多态是如何实现向一个方法传入不同的类型得到不同的结果？这里是因为出现了向上转型，即将子类对象地址赋值给父类引用。

public class Person {
    public String total(){
        return "这是父类";
    }
}
public class Student extends Person {
    @Override
    public String total(){
        return "这是子类";
    }
}
public class Demo{
    public static void main(String[] arg){
        Person p = new Student();
        System.out.println(p.total()); 
        //输出---这是子类
    }
}

        对象声明是Person类，但输出的却是Student 类的方法。这是多态的关键所在：Java实例方法调用是基于运行时实际类型动态调用，而并非引变量本身，这就是向上造型。

向下造型

        有向上转型自然有向下转型，如果想调用子类特有的方法必须向下转型，如下：

public class TextDemo {
    /*public static void main(String[] args) {
        Zi zi=new Zi();
        System.out.println(zi.getName());
        System.out.println(zi.getAge());*/
    public static void main(String[] arg){
        Person p = new Student();
        System.out.println( ((Student) p).stuTo() );
        //输出---这是子类特有方法

    }
}
class Person {
    public String total(){
        return "这是父类";
    }
}
class Student extends Person {
    @Override
    public String total(){
        return "这是子类";
    }
    public String stuTo(){
        return "这是子类特有方法";
    }
}

如果要调用子类的方法必须向下转型，即由父类型转为子类型。

注意：只有一个已经向上转型的子类对象才可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型