关于java中面向对象特征的总结

Java是一门面向对象的语言，不同于C语言的面向过程的是，Java中编写代码都是基于对象的。但是写了这么多代码，还是不能完整的表达出Java面向对象四大特征的一些特性，实践是基于理论的 ，于是总结一下：

• 抽象

　　抽象就是说把一些具有相同特征的对象的共同特征抽取出来，构成一个类，类的属性便是这些对象共有的特征。抽象只关注对象的哪些属性和行为,并不关注这此行为的细节是什么。

• 封装

　　封装就是将类中属性即成员变量以及操作成员变量的方法绑定起来，对数据的访问只能通过已定义的接口。可以说，封装就是隐藏一切可以隐藏的东西，只向外界提供最简单的接口，封装给对象提供了隐藏内部特性和行为的能力，对象提供一些能这被其它对象访问的方法来改变它内部的数据。

　　1.提供构造方法(有了构造方法才能通过new去构建一个对象 1.构造方法必须和类名称一样2.构造方法不能有返回值)，如果没有设置构造方法，会默认生成一个无参构造方法。

private Integer id;
    private String name;
    private Integer age;
    private String gender;

    public Person() {
    }

    public Person(Integer id, String name, Integer age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

　　构造方法也可以进行重载，这也是类中多态的表现，也叫编译时多态，下面将会讲解多态

public Person(Integer id, String name, Integer age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(Integer id, Integer age, String gender) {
        this.id = id;
        this.age = age;
        this.gender = gender;
        this.name = "andy";
    }

　　2.静态代码块(做的类的初始化的工作,执行在new之前)

　　说到静态代码块，就得说一下类的加载过程，类加载总共经过这几个步骤：加载（将.class文件加载到jvm虚拟机)->验证(验证代码的格式，变量的类型，方法的返回值等等是否正确)->准备(这一步也就是将方法区的静态变量，静态代码块中的内容，常量啊等等赋予初始值，如Integer就为0，引用类型就为null等等)->解析(解析就是将代码中的符号引用变为直接引用，符号引用是以字面量的实形式明确定义在常量池中，直接引用是指向目标的指针，或者相对偏移量)->初始化->使用->销毁

static {
        System.out.println("注册");

        System.out.println("报到");

    }

　　3. 控制访问，权限关键字

 　　如成员变量被private修饰，则只在当前类可以访问，于是便实现了屏蔽了外部来直接访问类内部的数据，而是通过类的内部接口即setter和getter来访问其成员变量和修改成员变量，但修饰的只是当前对象的，并没有改变类中的数据。

　　

 public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

• 继承（关键字：extends）

　　目的：对父类和方法的复用，也可以说是对父类的扩展。

　　继承是从已有类得到继承信息创建新类的过程,继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。子类继承父类属性(静态特征)和方法(动态特征)，继承必须遵循封装当中的控制访问。

　　Peson类中定义的通用方法

public void eat(){
        System.out.println("吃东西");
    }

　　子类Student继承Person，定义了自己的成员变量，定义了自己特有的方法，当然也可以对父类方法进行重写，这是多态中的内容。

public class Student extends Person {

    private String classId;

    public Student() {
    }

    public Student(Integer id, Integer age, String gender,String classId) {
        super(id, age, gender);
        this.classId = classId;
    }

    public void shangke(){
        System.out.println("去上课");
    }
}

Student student = new Student(1,21,"boy","3年2班");
        System.out.println(student);
        student.eat();
        student.shangke();

运行结果：

从上边的代码中可看出，子类中不要再定义属性和行为，直接继承父类，便有了父类的属性和行为，注意：访问修饰符决定了是否可继承

• 多态

　　多态性是指允许相同或不同子类型的对象对同一消息作出不同响应，多态两个重要特征就是向上转型和动态绑定。

　　1、 重载:同一个动作作用在同一个对象上拥有不同的解释 ，在同一个类中，方法的参数列表不同，用关键字注解@overload

　　如Person类重载的构造方法：

public Person(Integer id, String name, Integer age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public Person(Integer id, Integer age, String gender) {
        this.id = id;
        this.age = age;
        this.gender = gender;
        this.name = "andy";
    }

重载又称静态多态，编译时多态

　　2、 重写:

　　父类引用指向子类对象，在编译时，student就是Person对象，只能调用Person类中的方法，但在运行时，进行动态绑定，调用的却是子类重写父类中调用的那个方法。

Person person = new Student(1,21,"boy","3年2班");
        person.eat();

public void eat(){
        System.out.println("吃东西");
    }
}

@Override
    public void eat() {
        System.out.println("吃饭");
    }

同一个动作作用在不同的对象上拥有不同的解释 ，在子类与父类中，子类重写父类的方法，用关键字注解@override

重写又称动态多态，运行时多态