实现封装：（1）属性私有，（2）get/set方法
比如可以在set方法中设置一些条件，判断数据的合法性，从而提高程序的安全性
public void setAge(int age) {
if (age > 130 || age <0) { //如果赋值的年龄不合法，则将年龄恒设置为1
this.age=1;
}else {
this.age = age;
}
this.age = age;
}
封装的作用：
（1）提高程序的安全性，保护数据
（2）隐藏代码的实现细节
（3）统一接口
（4）增加系统的可维护性
public class Student {
//属性私有
private String name;
private int age;
//提供一些可以操作这些属性的方法（public的get、set方法）
//通过get方法获得这个数据
public String getName() {
return name;
}
//通过set方法给这个数据设置值
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age > 130 || age <0) { //如果赋值的年龄不合法，则将年龄恒设置为1
this.age=1;
}else {
this.age = age;
}
this.age = age;
}
}
在main 方法中通过new一个对象以及get和set方法，实现数据的操作
public class Application {
public static void main(String[] args) {
Student stu1 = new Student();
stu1.setName("望穿先生"); //设置值
System.out.println(stu1.getName()); //获取值并输出
}
}
2.继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
（注：Java中只有单继承，没有多继承）
-----继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
-----继承关系的两个类，一个为子类（派生类），一个是父类（基类）。子类继承父类，使用关键字extends来表示，extends的意思是“扩展”，子类是父类的扩展。
------子类和父类之间，从意义上讲具有“is a”的关系
Teacher is Person
Student is Person
public class Teacher extends Person{
}
public class Student extends Person {
}
子类继承了父亲，就会拥有父亲的全部方法和属性（前提是父类的public方法和属性）
private的属性可以通过get和set进行操作
注：在Java中所有的类都默认直接或者间接 继承Object类
Super注意点：super和this对比：（在new一个对象时，会先执行继承的父类的无参的构造方法，再执行本类的无参的构造方法）
1.super调用父类的构造方法时，必须在构造方法的第一个（第一行）
2.super必须只能出现在子类的方法或者方法或者构造方法中（如果在父类的话，就会调用到Object中去）
3.super和this不能同时调用构造方法（因为super和this都必须在构造方法的第一行，同时调用必然出错）
1.代表的对象不同：
this代表本身调用者这个对象
super代表父类对象的应用
2.前提不同：
this:没有前提也可以使用
super:只能在继承条件下可以使用
3.构造方法不同：
this():是本类的构造
super():父类的构造
例如在下面的Student类中，通过super调用父类的print()方法
Student类：
//Student继承了Person 类
public class Student extends Person {
public Student() {
System.out.println("Student的无参构造器");
}
private String name;
private int Id;
private char sex;
private int age;
public void say(String name){
System.out.println(name); //打印传递的参数name
System.out.println(this.name); //调用本类的name
super.print(); //调用父类的pring方法
}
}
Person类：
public class Person {
public Person() {
System.out.println("Person的无参构造器");
}
public void print(){
System.out.println("Person_print");
}
}
方法的重写（overide）
为什么需要重写？：因为父类的功能子类不一定需要，或者不一定满足
小结：
重写需要有继承关系，且必须是子类重写父类的方法（重写都是方法的重写和属性无关）
1.方法名必须相同；
2.参数列表必须相同
3.修饰符：范围可以扩大但是不能够缩小 public > protected > default >private (注：比如父类的方法protected，子类重写父类的方法时只能也是protected或者public，不能降低范围成private或者default)
4.抛出的异常：范围可以缩小，但不能扩大！
(静态方法是类的方法，非静态方法是对象的方法)
如果方法的修饰符中加了static，则在new一个对象进行方法调用时，只和等号左边定义的数据类型有关
例：
B类
public class B {
public static void test(){
System.out.println("B的test");
}
}
A类
public class A extends B{
public static void test(){
System.out.println("A的test");
}
}
此时A类继承B类,A类和B类中都有test()方法，且test()方法加了static修饰符,
那么在主函数中b.test() 调用的就是B类中的test()方法
//父类的引用指向了A B b = new A(); b.test(); //此时调用的是B类的test()
如果方法的修饰符中没有static,则new一个对象进行方法调用时，调用的是new的对象的方法
例：
B类
public class B {
public void test(){
System.out.println("B的test");
}
}
A类
//不加static的方法叫重写，子类A重写了父类B的test()方法
public class A extends B{
@Override
public void test(){ //方法的重写
System.out.println("A的test");
}
}
此时是非静态的方法，则b.test()调用的是new的对象，A类的test()方法
//父类的引用指向了A B b = new A(); b.test();3.多态
多态注意事项：
（1）多态是方法的多态，属性没有多态
（2）多态必须是有继承关系的父类和子类
（不是父类和子类关系的，就会报类型转换异常ClassCastException）
（3）多态的存在条件：有继承关系，子类重写父类方法，父类引用指向子类对象比如 father f1=new Son(); （father代表父类，son代表子类）
以下三种情况不能重写：
static修饰的方法（它属于类，不属于实例）final修饰的方法（ 是常量，所以不能重写）private修饰的方法（是私有的，所以不能重写）
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//实际类型确定，但是可以指向的引用类型就不确定了
Student s1 = new Student();
Person s2 = new Student(); //父类Person的引用类型指向子类Student
Object s3 = new Student();
s1.say(); //子类重写了父类的方法，则执行子类的方法
s2.say();
Person person = new Person();
person.say();
}
}
