面向对象自我总结

面向对象的三大特征：封装  继承  多态
--------------------------
封装方法
public int getage(){
       return this.age;
}
public void setage(int i){
       this.age=i;    
}
-------------------------
访问修饰符
public ：公开
protectad ：受保护的
default ： 默认的（缺省）
private ： 私有的
--------------------------
继承：extends
继承语法：class  子类 extends  父类｛｝

代码练习

先创建父类

public class fu {
    private String name;
    public void run() {
        System.out.println("动物在奔跑");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

}

再用extents关键字子类继承父类

class zi extends fu {
    // 打印一下名字
    public void printName(String name) {
        System.out.println("name=" + name);
    }
}

在main中把子类实例化测试

public  class Test  {
    public static void main(String[] args) {
        Rabbit r= new Rabbit();
// 通过父类方法为属性赋值
        r.setName("小白兔");
// 调用从父类继承的方法
        r.run();
// 调用本类方法
        r.printName(r.getName());
    }

}

继承的好处：

1.减少代码冗余，提高代码的复用性
2.便于功能的扩展
3.为之后的多态使用，提供前提

java关于继承的规定
1.一个类可以被多个子类继承
2.java中类的单继承性。一个类只能有一个父类（但可以有多个接口）
3.子类和父类是相对的概念。
4.子类直接继承的父类叫直接父类 ，间接继承的叫间接父类。
5.子类继承父类以后，就获取了直接父类以及间接父类的所有属性和方法
Object（祖类）
1.如果我们没有显示的声明一个类的父类的话，那么他继承于java.lang.Object类。
2.所有的java类（出Object）都直接或间接的继承Object类。
3.意味着，所有的类都具有java.lang.Object类所声明的功能。

super 关键字
#super ：代表父类的储存空间标识（可以理解为父类的引用）
#this    :代表当前对象的引用（当前对象）

总结：java支持单继承，不支持多继承（一个人只有一个父亲，但可以有多个干爹）
所有的类都可以直接或间接的继承Ojbect这个类，Ojbect是所有类的父类
-------------------------
抽象类
大概：
1.抽象方法：没有方法体的方法；
2.抽象类：含有抽象方法的类
抽象方法语法格式：修饰符 abstract 返回值类型  方法名  （参数列表）
抽象类语法格式： 修饰符 abstract class 方法名｛
    抽象方法
｝
 实例练习

用abstract声明一个抽象类

public abstract class  fuchouxian {
    public abstract void run();
    public abstract void eat();
}

再定义一个类去实现抽象类中的抽象方法

public class zhichouxian extends fuchouxian{
    public   void run(){
        System.out.println("跑跑跑");
    };
    public  void eat(){
        System.out.println("干饭干饭");
    };
}

最后在测试

public static void main(String[] args) {
    zhichouxian zhi = new zhichouxian();
    //继承抽象类需要重写抽象类内的所有抽象方法，否则也需要定义为abstract（抽象类）
    zhi.eat();
    zhi.run();

抽象类的基本应用：继承了抽象类的方法必须重写父类的所有抽象方法，否则该子类
也必须声明为抽象类。最终必须有子类实现该父类的抽象方法，否则该父类就失去了
意义
！！抽象类注意事项
1.抽象类不能创建对象，如果创建，编译无法通过而报错，只能创建其非抽象子类对象
2.抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
3. 抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也
是抽象类。
--------------------
接口
接口是一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员
方法，那么接口的内部主要就是封装了方法，包含常量、抽象方法（JDK 7及以前），默认方法和静态
方法（JDK 8）。
接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要
明确它并不是类，而是另外一种引用数据类型。
public class 类名.java-->.class
public interface 接口名.java-->.class
引用数据类型：数组，类，接口。
接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类
（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否
则它必须是一个抽象类。
--------------
接口的定义和使用
定义语法：
public interface 接口名称｛
常量
抽象方法
默认方法
静态方法
｝
使用接口格式
修饰符 class  类名  implements   接口
｛
重写接口中抽象方法【必须】
 重写接口中默认方法【可选】

｝
---------------

多态
1.什么是多态
多态是指同一个方法，具有多种表现形式。
2.多态的分类
对面向对象来说，多态分为编译时多态和运行时多态。其中编译时多态是静态的，主要是指方法的重
载，它是根据参数列表的不同来区分不同的方法。通过编译之后会变成两个不同的方法，在运行时谈不
上多态。而运行时多态是动态的，它是通过动态绑定来实现的，也就是大家通常所说的多态性。
   java实现多态有必须的三个条件：继承，重写，向上转型。只有满足这三个条件，开发人员才能在同一个
继承结构下使用统一的逻辑代码处理不同的对象产生不同的效果。
      继承：在多态中必须存在继承关系的子类和父类。
     重写：子类对父类中某些地方重新定义，在调用这些方法的时候就会调用子类的方法
      向上转型：在多态中需要将子类的引有赋给父类对象只有这种方法才能既调用父类
的方法又调用子类的方法。
---------------
向上转型
运行时多态一个最显著的例子就是子类上转型对象，既父类引用指向类对象，调用方法就是父类下包含
的方法执行的结果是子类重写后的。

向上转型代码练习：

创建一个父类

public class animal {
    String name;
    int age;
    public void eat(){
        System.out.println("动物：会跑");
    }
    public void ealk(){
        System.out.println("动物：会吃");
    }
}

多态的前提是继承和重写所有我们创建一个子类去重写父类

public class cat extends animal{
    public void call(){
        System.out.println("猫：喵喵叫");
    }
    public void eat(){
        System.out.println("猫四条脚跑");
    }
    public void ealk(){
        System.out.println("猫吃鱼");
    }
}

在main中测试

public static void main(String[] args) {
    cat ca = new cat();
    ca.call();
    
    System.out.println("********多态******");
    animal ca1 =  new cat();

    //对象的多态性：父类的引用指向子类的对象
    ca1.eat();
    ca1.ealk();

----------------------
多态的好处
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出
多态的扩展性与便利。
多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。