标签：静态方法 子类 多态 方法 面向对象 Student 父类 重写 三大
面向对象三大特性（封装、继承、多态）
1. 封装
1.装起来，只留一个口 该露的露，该藏得藏
2.高内聚（类的内部数据操作细节自己完成，不允许外部干涉）低耦合（仅暴露少量的方法给外部使用）
3.封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
4.记住属性私有private，get/set 一般属性要私有，属性要私有属性要私有属性要私有
（以前public属性 可以直接调用和赋值，现在private属性不能那样了，所以想操作这些私有属性，通过get、set来操作）
5.封装一般使对于属性 ，对于方法很少使用
封装的意义优点：
/*
* 封装的好处
* 1.提高程序的安全性，保护数据，防止破坏程序（如输入不切实际的年龄660岁）
* 2.隐藏代码的实现细节。
* 3.统一接口 get set
* 4.提高系统的可维护性。
*
* */
2. 继承
1.继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
2.extends 扩展，子类（派生类）是父类（基类）的扩展
3.Java中类只有单继承，没有多继承！（一个子类只能有一个父类，但一个父类可以有多个子类）
子类直接的只能继承一个父类，能间接的继承多个
4.继承是类和类之间的一种关系。（类和类之间的关系有：继承，依赖，组合，聚合）
5.继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，用关键字extends表示。
6.子类和父类之间，从意义上讲应该具有is a的关系。
7.在Java中，所有的类都默认直接或间接继承Object类
8.子类不能继承父类的私有方法或者属性
9.子类继承了父类，就会拥有父类全部的方法（当然父类的私有方法不行哦）
- 父类若没有无参构造器，子类则也写不了无参构造器 （只能在子类中 调用父类的有参构造 super("123");）
所以一般任何类写了有参构造之后，要把无参构造加上，即显示表达出来
this 和 super
this 指当前类的什么
super 指父类的什么
# super注意点
1.super调用父类的构造方法，必须在构造方法的第一个，第一行
2.super必须只能出现在子类的方法或者构造方法中（若在父类中调用super，则调用到父类的父类Object中去了）
3.super 和this 不能同时调用构造方法！ super() 和this()不能同时出现
# this
和super 代表的对象不同：
this: 本身调用者的这个对象
super:代表调用者的父类对象的引用
前提
this:没有继承也可以使用
super：只能在继承条件下才能使用
构造方法
this(); 调用本类的无参构造 this("123"); 调用本类的有参构造
super(); 调用父类的无参构造！super("123"); 调用父类的有参构造
调用子类的无参构造器时，父类的无参构造器先执行，（默认在子类的构造器中，有super()在第一行）
方法的重写
方法重写是子类父类才有的，子类继承父类之后，子类重写父类的方法，是执行子类的方法，并不是改变父类的方法
重写的方法跟父类的被重写方法长的一样，只是方法的实现不同（方法体不同）
重写都是方法的重写，和属性无关，且重写是针对非静态方法的，与静态方法无关
重写的方法只能是public的 ,不能是private的
///静态方法和非静态方法区别很大！
//静态方法：静态方法的调用只和左边，定义的数据类型有关。
//非静态方法：才是重写！！
//静态方法的调用只和左边，定义的数据类型有关。
B b = new A();//父类的引用指向了子类 父类：B 父类的引用：b 指向了子类：= new A();
重写非静态方法，子类重写了父类的方法。
静态方法和非静态方法区别很大！
总结：方法的重写
# 总结：方法的重写 Alt + Insert 选Override Methods
前提：需要有继承关系，子类父类中才有的，子类继承父类，子类重写父类的方法。
重写是针对方法的，而且是非静态方法（与静态方法无关），与属性无关。
1. 方法名需要相同（子类中重写的方法和父类中被重写的方法名需要相同）
重写：子类的方法和父类必须一致，方法体不同！
2. 参数列表必须相同
3. 修饰符：范围可以扩大，不能缩小 （public > protected > default > private）
4. 抛出的异常：范围可以被缩小，但不能扩大 ClassNotFoundException --> Exception(大)
## 为什么需要重写？
1.父类的功能，子类不一定需要，或者不一定满足！
哪些方法不能被重写？？
* 哪些方法不能被重写？
* 1.static方法 ，属于类，不属于实例。
* 2.final 常量池里的 不能改变
* 3.private 方法 私有的 也不能被重写！
代码演示
public class Application {
public static void main(String[] args) {
System.out.println("Hello World !");
A a = new A();
System.out.println(a);
a.test();
B b = new B();
System.out.println(b);
b.test();
//方法重写 方法重写是针对非静态方法的，与静态方法无关，与属性无关
System.out.println("---------方法重写--（针对非静态方法）--修饰符范围可以变大，不能缩小------");
//抛出的异常：范围可以被缩小，但不能扩大 ClassNotFoundException --> Exception(大)
//父类 和子类都是public方法 可重写
//父类是protected方法 ，子类修饰符范围不能变小，可以是protected方法，也可以是public方法
//（public > protected > default > private）
B a1 = new A();
System.out.println(a1);
a1.test();
}
}
3. 多态
动态编译 ：类型 ：可扩展性
同一方法可以根据发送对象的不同而采用多种不同的行为方式。（都是run（），执行的结果不一样）
一个对象的实际类型是确定的，但是它可以指向的引用类型就不确定了（父类或者有关系的类）
对象能执行哪些方法，主要看对象左边的类型（和继承关系），和右边关系不大！（子类重写父类方法，那就执行子类的方法）
//一个对象的实际类型是确定的。
//它可以指向的引用类型就不确定了:父类的引用指向了子类的类型
Student s1 = new Student();/*一个类的实际对象的类型是确定的 都是Student*/
Person s2 = new Student();/*但它指向的引用类型是不确定的，现在是它的父类型*/父类的引用指向了子类的类型
Object s3 = new Student();/*但它指向的引用类型是不确定的，现在是它的祖宗类型*/祖宗类型的引用指向了子类的类型
//多态：都是new的Student()，但是对象的类型不同（Student Person Object）
//前提 ，有父子关系或祖宗关系！例如Student继承了Person,
没关系的肯定不行(Student 和 String 无关，所以不能String s4 = new Student();)
//Student 能调用的方法都是自己的或者继承父类的！
Student s1 = new Student();
//Person 父类型，可以指向子类，但是不能调用子类独有的方法
/*****父类的引用指向了子类*******/
Person s2 = new Student();
Object s3 = new Student();
/*总结：
*拥有继承关系后，可以Person s2 = new Student();
* Student s1 = new Student();/*一个类的实际对象的类型是确定的 都是Student
* Person s2 = new Student();/*但它指向大的引用类型是不确定的，是它的父类型和祖宗类型
*
*
*对象能执行哪些方法，主要看对象左边的类型（和继承关系），和右边关系不大！
*没重写时，父亲自己有这个方法,父亲对象执行父亲的方法 2.子类重写了父类的方法，所以父亲对象执行的是子类的方法
*
* */
多态的注意事项
/*多态的注意事项
* 1.多态是方法的多态，属性没有多态 重写也是针对非静态方法的，与属性和静态方法无关
* 2.父类和子类，有联系，String Perosn 类型转换异常ClassCastException
String s4 = new Student(); 是不行的 （因为String 和Student无关）
* 3.多态存在的条件: 有继承关系，方法需要重写, 父类引用指向子类对象！ Father f1 = new Son();
*
*
*
* 哪些方法不能被重写？
* 1.static方法 ，属于类，不属于实例。
* 2.final 常量池里的 不能改变
* 3.private 方法 私有的 也不能被重写！
*
* */
注意点：
1. 封装是对于属性，很少封装方法
2. 继承是类和类之间的一种关系 （所有类默认都继承Object类,Object类是所有类的父类或祖宗类）
（类和类之间的关系有：继承，依赖，组合，聚合）
3. 多态是方法的多态，属性没有多态
方法重写是针对非静态方法的，与静态方法无关，与属性无关
判断两个方法是否相同（1.方法名 2. 参数）
封装 之后 才能继承 继承之后才能多态
对象能执行哪些方法，主要看对象左边的类型（和继承关系），和右边关系不大！
*没重写时，父亲自己有这个方法,父亲对象执行父亲的方法 2.子类重写了父类的方法，所以父亲对象执行的是子类的方法
标签：静态方法,子类,多态,方法,面向对象,Student,父类,重写,三大 来源： https://www.cnblogs.com/intelliyu/p/16096510.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。