Java面向对象三大特征

Java面向对象三大特征（封装、继承、多态）

1.封装

什么是封装？
在我们的程序设计中，追求”高内聚，低耦合“。高内聚即在一个类中，内部的数据操作细节自己完成，不让外部进行干涉。低耦合即只提供少量的方法给外部使用，外部无法影响我内部的数据操作。
举个栗子：
一名厨师炒菜，需要放油、控制火候、放盐、出锅等，都由该厨师一个人完成。但他不洗菜，菜由外部提供。无论外部提供什么菜，具体炒菜的细节还是由厨师控制。
在Java中封装就是将类的信息隐藏在类内部，不允许外部程序进行直接访问，通过该类的方法实现对隐藏信息数据的操作和访问。能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

实现封装

public class Person {

    //身份证号
    private String id;
    //姓名
    private String name;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        if (!id.equals("admin")){
            this.id = id;
        }
        System.out.println("不能设置为admin");
    }

    public String getName() {
        return name;
    }

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

我们将属性的访问修饰符设置为private，即将id与name设置为私有，只有本类可以使用其他类都访问不了，如此就对信息进行了隐藏。 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，并且我们可以在这些方法中设置一些校验，如上代码中的setId方法，如果id等于admin则不对属性进行赋值。

封装的优点：

1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

2.继承

继承就是将基于已经有的类，创造除一个新的类。新的类可以继承其原有的方法，属性，并可以对其增加新的方法，修改已有的方法。继承是Java程序设计中一项核心技术，它主要解决的问题是：共性的抽取，实现代码复用。

public class Person {

    //身份证号
    public String id;
    //姓名
    public String name="张三";

    //吃饭
    public void eat(){
        System.out.println(name+"吃饭");
    }

    //说话
    public void say(){
        System.out.println(name+"在说话");
    }
}

public class Man extends Person{
    private String gender;


    @Override
    public void say() {
        System.out.println("哑巴不会说话");
    }

    public void work(){
        System.out.println(super.name+"搬砖");
    }
}

public class Demo {
    public static void main(String[] args) {
        Man man = new Man();
        man.eat();
        man.say();
        man.work();
    }
}

以上代码运行结果是

类与类的继承通过extends关键字，被继承的类被称为父类，继承的类称为子类。子类继承父类子类具备父类的所有公有属性及方法。如man类继承了person类，则man类就称为person的子类。子类可以复用父类的方法和属性，也可以对父类方法进行重写，子类在实现时只关心自己新增加的成员即可。子类还可以通过super关键字调用父类的方法或属性。
public修饰的为共有属性。 在java中类的修饰符：private 、default（package）、protect、public，其范围如下表：

范围	private	default	protected	public
同一类	√	√	√	√
同一包中的类		√	√	√
同一包中的类、不同包中的子类			√	√
所有				√

3.多态

多态的条件：
1.子类继承父类
2.子类重写父类方法
3.父类引用指向子类对象
例：

public class Parent {
	public String name="Parent";
	public int age=20;
	
	public Parent() {
		System.out.println("父类无参构造方法");
	}

	public Parent(String name, int age) {
		System.out.println("父类有参构造方法");
		this.name=name;
		this.age = age;
	}
	
	public void save() {
		System.out.println("名称"+name+",年龄"+age);
		System.out.println("父类save方法");
	}
	 
	public void say() {
		System.out.println("父类say方法");
	}
	
}
public class Son extends Parent{
	public String name="Son";
	public int age=3;
	

	public Son() {
		System.out.println("子类无参构造方法");
	}

	public Son(String name, int age) {
		System.out.println("子类有参构造方法");
		this.name = name;
		this.age = age;
	}

	@Override
	public void save() {
		System.out.println("名称"+name+",年龄"+age);
		System.out.println("子类save方法");
	}
}
public class Demo {
	public static void main(String[] args) {
		Parent son = new Son("张三",10);
		son.save();
		System.out.println(son.name);
		son.say();
	}
}

运行结果如下图：

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再判断子类是否重写，重写调用子类的同名方法，未重写调用父类方法。多态成员变量：编译运行看左边；多态成员方法：编译看左边，运行看右边。

多态的好处：消除类型之间的耦合关系，使程序有良好的扩展，并可以对所有类的对象进行通用处理。

多态的转型
多态的转型分为向上转型和向下转型两种
向上转型：多态本身就是向上转型过的过程
使用格式：父类类型 变量名=new 子类类型();
适用场景：当不需要面对子类类型时，通过提高扩展性，或者使用父类的功能就能完成相应的操作。
向下转型：一个已经向上转型的子类对象可以使用强制类型转换的格式，将父类引用类型转为子类引用各类型
使用格式：子类类型 变量名=（子类类型） 父类类型的变量；
适用场景：当要使用子类特有功能时。