Java-面向对象的三大特征

一.面向对象的三大特征

封装 多态 继承

1.封装

       在Java中为了保护对象的属性和方法，通常通过添加访问控制阀private来保护相应的属性和方法。如下Dog类，通过private来保护name和age,外界只可以通过set和get方法对name和age进行访问。

public class Dog {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

2.多态

即方法的重载和重写，有一篇专门叙述。

3.继承

    即子类可以通过访问extends继承父类中的属性和方法。

    注意：一个子类只能继承一个父类即单继承，但一个父类可以同时被多个子类继承。

父类：

package Test;

public class Student {
    String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public static void learn(){
        System.out.println("每个学生都学习");
    }
}

子类：

package Test;

public class HighSchoolStudent extends Student{
   public void learn(){
        System.out.println("高中生学习的科目很广泛");
   }

    public static void main(String[] args) {
       //这里本是HighSchoolStudent,但是因为HighSchoolStudent继承了Student，所以也可以用Student
        HighSchoolStudent s = new HighSchoolStudent();
        System.out.println(s.age);
        s.setName("Snoopy");
        System.out.println(s.getName());
        s.learn();
    }
}

二.抽象类

       是一种包含抽象方法的类，不能被实例化，只能被继承。抽象类是没有方法实现的，需要子类去实现。抽象类可以包含普通方法和成员变量，也可以包含抽象方法。

public abstract class Student{
    String name = Snoopy;
    public abstract void learn();
    public void speak(){
          System.out.println("语言");
   }
}

        定义抽象类时，需要在class前加abstract。在抽象类中可以定义未完成的方法，但在子类中需要重写；也可以定义完整的方法，在子类中直接调用。

子类：

package Test;

public class HighSchoolStudent extends Student{
    //对未完成的方法进行重写
    public void learn(){
       System.out.println("高中生学习的很广泛");
    }

    public static void main(String[] args) {
       HighSchoolStudent s = new HighSchoolStudent();
       System.out.println(s.name);
       s.learn();
       s.speak();
    }
}

运行结果：

三.接口

      用interface定义

      接口是一种抽象类型，它定义了一组抽象方法和常量，但没有实现方法。

      接口可以被类实现，一个类可以实现多个接口。通过实现接口，类可以定义自己的行为，实现接口中定义的方法。

      与抽象类进行比较，一个子类只能继承一个抽象类，但一个子类可以继承许多接口。

    

package Test;
    interface Animal {
        void eat();
        void sleep();
    }
    interface go{
        void walk();
    }

    // 实现接口,继承多个接口
    class Cat implements Animal,go {
        @Override
        public void eat() {
            System.out.println("Cat eat");
        }

        @Override
        public void sleep() {
            System.out.println("Cat sleep");
        }
        @Override
        public void walk(){
            System.out.println("Cat walk");
        }
    }

    public class CatDemo {
        public static void main(String[] args) {
            Cat cat = new Cat();
            cat.eat();
            cat.sleep();
            cat.walk();
        }
    }