java05

多态

多态是同一个行为具有不同表现形式和形态的能力
多态就是同一个接口，使用不同实例而执行不同操作

 class Animal05{
     public void eat() {
         System.out.println("吃所有");
     }
     public void sleep()
     {
         System.out.println("睡着了");
     }
 }

class Cat05 extends Animal05 {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void work() {
        System.out.println("抓老鼠");
    }
}

class Dog05 extends Animal05 {
    public void eat() {
        System.out.println("吃骨头");
    }
    public void work() {
        System.out.println("看家");
    }

}
 public class Main05 {

        public  static void main(String[] args) {
            Animal05 a = new Animal05();//根据所指对象的实际类型来调用方法
            a.eat();
            a.sleep();
            Animal05 b = new Cat05();
            b.eat();
            b.sleep();
            Cat05 c = new Cat05();
            c.eat();
            c.sleep();
            Animal05 d = new Dog05();
            d.eat();
            d.sleep();//子类没有重写，则调用父类的方法
            Dog05 e = new Dog05();
            e.eat();
            e.sleep();
}
}

（一）多态存在的三个必要条件：

继承、重写、父类引用指向子类的对象 Parent p = new Child();

（二）虚函数：

虚函数的存在是为了多态
java中没有虚函数的概念，他的普通函数就相当于c++的虚函数，动态绑定是java的默认行为，如果java中不希望某个函数具有虚函数的特性，只需要加上final关键字变成非虚函数

（三）重写

当子类对象调用重写方法时，调用的是子类的方法而不是父类中被重写的方法
想要调用父类中被重写的方法，则必须使用supper关键字

（四）多态的实现方法：

重写、接口（一些方法特征的集合，但是没有方法的实现）、抽象类和抽象方法（java抽象类）

二、抽象类

（一）抽象类

在面向对象的概念中，所有的对象都是通过类来描述的，但是反过来，并不是所有类都是用来描述对象的，如果一个类中没有足够的信息来描述对象，这样的类就是抽象类
抽象类除了不能实例化对象之外，类的其它功能依旧存在，其它功能和普通类一样
由于抽象类不能实例化对象，所以抽象类必须被继承，才能够被使用，因此在设计阶段就决定要不要设计抽象类
父类包含了子类集合的常见方法，但是因为父类本身是抽象的，所以不能使用这些方法
在java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类可以实现多个接口

//抽象类
abstract class chouxiang{
    private String name;
    private int id;
    private int age;

    public chouxiang(String myname,int myid,int myage){
        this.name=myname;
        this.age=myage;
        this.id=myid;
    }
    public void getname(){
        System.out.println(name);
    }
    public void getid(){
        System.out.println(id);
    }
    public void getage(){
        System.out.println(age);
    }

}
//继承抽象类
class jicheng extends chouxiang{
    public jicheng(String myname, int myid, int myage) {
        super(myname, myid, myage);
    }

}
    public class Main05 {

        public  static void main(String[] args) {
            chouxiang f=new jicheng("小红",18,17);//继承来访问抽象类的方法
            f.getage();
            f.getid();
            f.getname();
            jicheng g=new jicheng("小明",22,22);
            g.getage();
            g.getid();
            g.getname();
        }
    }

（二）抽象方法

如果你想设计一个类，该类包含一个特别的成员方法，该方法的具体实现由他的子类确定，那么你可以在父类中声明该方法为抽象方法
abstract关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体
抽象方法没有定义，方法名后面直接跟一个分号而不是花括号
声明抽象方法会造成以下两个结果：
任何一个类包含抽象方法，那么它就是抽象类
任何子类必须重写父类的抽象方法，或者自身声明为抽象类

（三）抽象类总结

1、抽象类不能被实例化
2、抽象类中不一定包含 抽象方法
3、抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能
4、构造方法，类方法（用static修饰的方法）不能声明为抽象方法
5、抽象类的子类必须给出抽象类中抽象方法的具体实现

三、java封装

（一）封装

在面向对象的设计方法中，封装是指一种将抽象性函数接口的实现细节部分包装、隐藏起来的方法
封装可以被理解成是一个屏障，防止该类的代码和数据被外部定义的代码随机访问
要访问该类的代码和数据，必须通过严格的接口控制
封装的主要功能在于我们能修改自己的实现代码，而不用修改哪些调用我们代码的程序片段
适当的封装可以让程式码更容易理解和维护，也增强了程式码的安全性

//封装
//public 方法是外部访问类访问该成员变量的入口
class person{
    private String name;
    private int id;
    private int age;

    public void getname01(){
        System.out.println(name);
    };
    public void getid01(){
        System.out.println(id);
    };
    public void getage01(){
        System.out.println(age);
    };
}

（二）封装的优点

1、良好的封装能够减少耦合
2、类内部的结构可以自由修改
3、可以对成员变量进行更精准的控制
4、印象信息实现细节