封装、继承、多态

1.封装

封装就是将一些数据隐藏起来，禁止直接访问一个对象中的某些数据，转而通过操作接口（get/set）来访问。

属性私有，get/set

举例说明：

public calss Student{
    //将这些学生属性设置为私有，禁止对这些属性的直接访问
    private String name;//学生姓名
    private int age;//年龄
    
    //用来操作私有属性的方法
    public String getName(){	//获取对象姓名
        return this.name;
    }
    public void setName(String name){	//设置对象姓名
        this.name = name;
    }
    
    public int getAge(){		//获取对象年龄
    	return this.age;    
    }
    public void setAge(int age){		//设置对象年龄
        this.age = age;
    }
}

Student stu1 = new Student();
/*
将属性设置为私有之后，将不能在通过stu1.name/stu1.age的形式对属性进行访问
如果需要获取/设置属性数据，可以通过以下方式：
*/
stu1.setName("小明");//设置stu1姓名为小明
stu1.setAge(25);//设置stu1年龄为25
String strTmp1 = stu1.getName();//获取stu1的姓名
int intTmp1 = stu1.getAge();//获取stu1的年龄

封装了数据有什么用？

1. 使程序更加安全，能够保护数据
2. 隐藏了代码的实现细节
3. 统一接口的使用模式
4. 更加容易对系统进行维护

用get/set来操作数据可以对数据进行约束和控制

例如：

//在这里可以对属性的设置进行约束，防止一些不合法的设置
public void setAge(int age){		//设置对象年龄
    if(age >= 0 || age < 150)	//合理的年龄输入则成功记录
        this.age = age;
    else						//不合理的输入则排除
        this.age = 0;
}

---

2.继承

继承是某些类的共同特征的抽象，从而可以实现现实中建模的更优解。

具有继承关系的类和类可以分为子类（派生类）和父类（基类）

关键字extends（扩展）：子类是父类的扩展。并且子类的范畴一定小于（包含于）父类之中。

举例说明：

//Person类作为父类，Student类和Teacher类作为子类，Student和Teacher都属于Person。
public class Person{
    //不管是老师还是学生，都有姓名和年龄的属性
    private String name;
    private int age;
    
    public String getName(){	//获取对象姓名
        return this.name;
    }
    public void setName(String name){	//设置对象姓名
        this.name = name;
    }
    
    public int getAge(){		//获取对象年龄
    	return this.age;    
    }
    public void setAge(int age){		//设置对象年龄
        this.age = age;
    }
    
    public void move(){
        System.out.println(this.name + "进行了移动！");
    }
}

//子类 - Student类
public class Student extends Person{
    
}
//子类 - Teacher类
public class Teacher extends Person{
    
}

现在即使两个子类并没有编写内容，但在如下代码调用的时候，仍然可以使用其父类中的方法，这就是继承！

（需要注意：父类中私有的内容无法被继承）

public static void main(String[] args) {
	//这里创建的是student类，但使用的方法却是在Person类中实现的
    Student stu1 = new Student();
    stu1.setName("小明");
    stu1.setAge(25);

    //这里调用了其父类的方法，并且调用成功,输出了“小明进行了移动！”
    stu1.move();
}

---

3.多态

同一个方法可以根据发送对象的不同而采用多种不同的行为方式

一个对象的实际类型是确定的，但是可以指向对象的引用的类型有很多

理解方式：

按下键盘的q键

• 在游戏中会释放一个技能

• 在某系统中会实现退出功能

• 在文本框会写下一个“q”字母

同样是按下了q键，但却有着多种不同的表现形式

多态的存在条件：

1. 存在继承关系
2. 子类重写了父类的方法
3. 父类引用指向子类对象

需要注意：多态是方法的多态，属性不存在多态性

举例说明：

//父类
public class Person {
    public void testOne(){
        System.out.println("Person类测试！");
    }
}

//子类
public class Student extends Person{
    public void testOne(){
        System.out.println("Student类测试！");
    }
    public void testTwo(){
        System.out.println("Student类测试！！");
    }
}

其中，子类对父类的testOne();方法进行了重写，没有对testTwo();进行重写。

public static void main(String[] args) {
        //一个对象的实际类型时确定的，stu1/stu2都是Student类型
        Person stu1 = new Student();//父类的引用指向子类的类型
        Student stu2 = new Student();

        stu1.testOne();//由于子类重写了父类的方法，所以该处会执行子类的方法
        stu2.testOne();

        //stu1.testTwo();//该行报错
        stu2.testTwo();
    }

结果表明，在实际的调用中

由于testOne();进行了重写，stu1和stu2都会调用到子类中的方法，

而由于testTwo();没有重写，Person中并没有该方法，所以stu1.testTwo();会报错

多态有什么优点？

1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性