面向过程和面向对象、面向对象的三大特性（继承、封装、多态）

面向过程和面向对象都是对软件分析、设计和开发的一种思想，它指导着人们以不同的方式去分析、设计和开发软件。（相辅相成）

1. 都是解决问题的思维方式，都是代码组织的方式
2. 解决简单问题可以使用面向过程
3. 解决复杂问题：宏观上使用面向对象把握，微观处理上仍然是面向过程

面向过程：适合简单任务，不需要过多协作的事务（一步一步完成）

面向对象：适合复杂问题，需要大量合作

对象的发展过程：数据无管理时代——数组管理（企业部门制）——对象（企业项目制）

类：属性（成员变量field）+方法

面向对象的三大特征：继承、封装、多态

继承使用要点;

1、接口可以多继承，类只能单继承（只有一个父类）
2、可以得到父亲的全部属性和方法（除了父亲的构造方法），但不见得可以直接访问（比如，父亲私有的属性和方法）
3、如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object(可以右击点击Diagrams查看类的继承层次结构或者Ctrl+h）

package cn.sxt.oo;

public class TestExtends {
    public static void main(String[] args){
        Student stu = new Student("高小七","挖掘机");
        stu.rest();
        stu.study();
        Student stu2 = new Student("高小八","计算机");
        stu2.study();
        System.out.println(stu2 instanceof Person);
        }
}
class Person extends Object{
    String name;
    int height;
    public void rest(){
        System.out.println("休息一会！");
    }

}
class Student extends Person {
    String major;

    public void study() {
        System.out.println("学习Java");
    }


    public Student(String name, String major) {
        this.name = name;
        this.major = major;
        this.height = height;
    }
}

instanceof 用于判断左边的对象是不是从属于右边的类
封装：

1. private表示私有，只有自己类能访问
2. default表示没有修饰符，只有同一个包的类能访问
3. protected表示可以被同一个包的类以及其他包的子类访问
4. public表示可以被该项目的所有包中的所有类访问

package cn.sun.oo;

/**
 * 测试封装
 *
 */
public class TestEncapsulation {
    public static void main(String[] args){
        Human h = new Human();
        h.sayAge();
        //h.age = 18;
        h.name = "高淇";
        h.height = 180;
    }


}

class Boy extends Human{
    void sayHello(){
        System.out.println(name);

    }
}

package cn.sun.oo;

public class Human{
    private int age;
    String name;//可以被本包下面的类访问
    protected int height;
    public void sayAge(){
        System.out.println(age);
    }
}

package cn.sxt.oo;
import cn.sun.oo.Human;

public class TestEncapsulation2 {
    public static void main(String[] args){
        Human h = new Human();
        //h.age = 13;
        //h.name = "高淇";  //name 为default属性，不能被不同包访问
        h.sayAge();
    }

}
class Girl extends Human{
    void sayGood(){
        System.out.println(height);
    }
}

 封装的使用细节

1. 一般使用private访问权限
2. 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作（注意：boolean变量的get方法是is开头！！！）
3. 一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰

JavaBean的封装（没有复杂关系的简单的类）

属性私有private，属性的方法(提供get/set方法)公开public,没有其他复杂的方法。

package cn.sun.oo;

/**
 * 仍然测试封装
 */
public class Person4 {
    private int id;
    private String name;
    private int age;
    private boolean man;

    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        if(age>=1&&age<=130) {
            this.age = age;
        }else{
            System.out.println("请输入正确年龄!!");
        }
    }

}

package cn.sun.oo;

/**
 * 测试封装
 *
 */
public class TestEncapsulation {
    public static void main(String[] args){
        Human h = new Human();
        //h.sayAge();
        //h.age = 18;
        h.name = "高淇";
        h.height = 180;


        Person4 p4 = new Person4();
        //p4.age = 14;
        p4.setAge(-10);


    }


}

多态的要点

1. 多态是方法的多态，不是属性的多态（多态与属性无关）
2. 多态存在要有三个必要条件：继承，方法重写，父类引用指向子类对象
3. 父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了

package cn.sun.oo;
/*
测试多态
 */

public class TestPolym {
    public static void main(String[] args) {
        Animal a = new Animal();
        animalCry(a);
        Dog b = new Dog();
        animalCry(b);
        Cat c = new Cat();
        animalCry(c);


    }

    static void animalCry(Animal a) {
        a.shout();
    }
}
class Animal{
    public void shout(){
        System.out.println("叫了一声");
    }
}
class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪汪");
    }
}
class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵");
    }
}

对象的转型：

向上转型：子类可以自动转为父类（自动类型转型）

向下转型：父类转为子类（手动强制转型）

package cn.sun.oo;
/*
测试多态
 */

public class TestPolym {
    public static void main(String[] args) {
        /*Animal a = new Animal();
        animalCry(a);
        Dog b = new Dog();
        animalCry(b);
        Cat c = new Cat();
        animalCry(c);

         */
        Animal d = new Dog();
        Animal c = new Cat();
        Dog d2 = (Dog)d;
        d2.seeDoor();
      /*  Dog d3 = (Dog)c;
        d3.seeDoor();
        //猫不能强制转为狗，编译会通过，但运行时会报错
       */


    }

    static void animalCry(Animal a) {
        a.shout();
    }
}
class Animal{
    public void shout(){
        System.out.println("叫了一声");
    }
}
class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪汪");
    }
    public void seeDoor(){
        System.out.println("看门");
    }
}
class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵");
    }
}