JAVA基础——面向对象的特征

面向对象的特征

1. 封装性：

为例实现程序的“高内聚，低耦合”，防止外部程序干涉才引入封装性
封装性的体现：
a） 我们将类的属性XXX私有化（private），同时提供（public）的getXXX（）和setXXX（）的方法，
b） 不对外暴漏类的私有的方法
c）单例模式 （将构造器私有化，外部代码不能随便构造对象）
d）封装需要使用权限修饰符来进行修饰

权限修饰符的范围：

范围	类内	包内	不同包子类	同一个工程
private	√	×	×	×
default	√	√	×	×
protected	√	√	√	×
public	√	√	√	√

构造器
作用：1、创建对象 ；2、初始化对象的信息（即属性）。
如果没定义，系统则提供一个无参构造器；如果写了有参构造器，则会覆盖默认构造器
一个类中构造器可以构造多个，方法名必须和类名相同，无返回值。
构造器彼此构成重载。
默认的构造器的权限和类的权限相同。
一个类中，至少包含一个构造函数。

在这里插入代码片

属性赋值先后顺序

1. 默认初始化
2. 显示初始化
3. 构造器中赋值
4. 通过“对象.方法”或“对象.属性”的方式赋值

2. 继承性：

1. 继承性的好处：
   a）减少了代码的冗余，提高了代码的复用性
   b）便于功能的扩展
   c）为多态提供了前提

2. 继承性的格式:
   class Man extends Person

3. 继承的体现：
   a）子类继承父类后，子类可以调用父类的所有属性和方法（包括私有结构）。
   由于封装性的影响，使得子类不可以直接调用父类的结构
   b）子类继承还可以自己添加自己的方法和属性，实现功能的扩展。

4. 继承的规定：
   a）一个类可以有多个子类继承
   b）java中类是单继承，一个子类只能继承一个父类（接口可以多继承）
   c）继承可以延续多个，生成间接性的继承 A <- B <- C

5. 所有类的父类：
   如果没有显示的声明一个类的父类，则此类默认（直接或间接）继承与java.lang.Object类。

package test0819;

/**
 * @param
 * @author 
 * @deception  父类
 * @date 2019/8/17 9:52
 * @return
 */
public class Person {
    private String name;
    private int age;
    private String sex;

    public void info(){
        System.out.println("==父类==");
    }

    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;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public static void main(String[] args) {
        Person person =new Person();

        //继承父类的方法
        Man man = new Man("teacher");
        //man.age = 20;  错误写法，由于父类已经私有化了，不能直接调用父类的私有属性，但在对内存中已经生成属性的位置
        
        //私有属性只能使用方法，保证了父类的封装性
        man.setName("张三"); 
        man.setAge(21);  
        man.setSex("男");
        man.info();   //调用父类方法
        System.out.println("个人信息：姓名 "+man.getName()+" 性别 "+man.getSex()+" 年龄 "+man.getAge()+" 工作 "+man.getWork());
        man.show();
    }
}
/**
 * @param
 * @author 
 * @deception  子类
 * @date 2019/8/17 9:55
 * @return
 */
class Man extends Person{
    private String work;

    public Man(){
    }

    public Man(String work) {
        this.work = work;
    }

    public void show(){
        System.out.println("my work is"+work);
    }

    public String getWork() {
        return work;
    }

    public void setWork(String work) {
        this.work = work;
    }
}

3.多态性

多态性必须在继承的情况下才会有多态性。
格式：Person person = new Man(); Man继承Person。
在编译时只能调用父类的方法，执行时执行子类重写的方法。

package test0808;

/**
 * @ClassName Person
 * @Description 多态性
 * @Author 王琛
 * @Date 2019/8/21 9:01
 * @Version 1.0
 */
public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void printMesage(){
        System.out.println("name:"+name+",age:"+age);
    }

    public void show(){
        System.out.println("这是父类");
    }
}

class Man extends Person{
    private String sex;

    public Man(String name, int age, String sex) {
        super(name, age);
        this.sex = sex;
    }

    public void show(){
        System.out.println("这是子类");
    }

    public void print(){
        System.out.println("这个方法没有重写父类");
    }

    public static void main(String[] args) {
        Person person =new Man("张三",20,"男");
        person.printMesage();   //执行的父类，因为没有重写
        person.show();  //执行的子类
        //person.print();  错误写法
    }
}

运行结果