面向对象高级训练
1、继承
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
继承的限制：
继承只有单继承、多重继承，没有多继承。（一个子类只有一个父类，一个孩子只有一个爹）
C如何继承A、B呢？B先继承A，C再继承B，多重继承。
子类实例化内存图解：
2、Super
通过super可以访问父类构造方法
通过super可以访问父类的属性
通过super可以访问父类的方法
public class Demo1 {
public static void main(String[] args) {
Student stu = new Student();
stu.say(); ==//通过super可以访问父类的方法==
}
}
class Student extends Person{
public Student(){
super("无名称",1); ==//通过super可以访问父类构造方法==
super.setName("Lucy"); ==//通过super可以访问父类的属性==
super.setAge(18);
}
}
class Person{
…………
}
3、重写
重写概念：方法的重写，发生在类的继承中。
public class Demo {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student stu = new Student();
stu.say();
}
}
class Person{
//父类中的say方法
public void say() {
System.out.println("锄禾日当午");
}
}
class Student extends Person{
public void say() {//子类对 父类Person中的say方法 继承后进行重写
System.out.println("窗前明月光，玻璃好上霜。若不即使擦，整不好得脏。");
}
}
输出：窗前明月光，玻璃好上霜。若不即使擦，整不好得脏。
重载的概念：方法名称相同, 参数类型或参数长度不同, 可以完成方法的重载
一个类, 可以存在多个构造方法 :
参数列表的长度或类型不同即可完成构造方法的重载 ~
构造方法的重载 ,可以让我们在不同的创建对象的需求下, 调用不同的方法来完成对象的初始化!
重写(override)规则:
1、参数列表必须完全与被重写方法的相同;（example：父类不传参，子类也不传参）
2、返回类型必须完全与被重写方法的返回类型相同;（example：父类无返回值，子类也返回值）
3、访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected.
4、父类的成员方法只能被它的子类重写 。（在继承后才能被重写）
5、声明为static和privete的方法不能被重写，但是能够被再次声明。
面试题:
Java中重写(Override) 与重载(Overload)的区别
1、 发生的位置
重载:一个类中
重写:子父类中
2、参数列表限制
重载:必须不同的
重写:必须相同的
3、返回值类型
重载:与返回值类型无关
重写:返回值类型必须一致
4、访问权限:
重载:与访问权限无关
重写:子的方法权限必须不能小于必父的方法权限
5、异常处理:
重载:于异常无关
重写:异常范围可以更小，但是不能抛出新的异常。
4、final关键字
用处：固定的执行流程，可以用final
final用于修饰属性、变量。
final用于修饰类
fina1用于修饰方法
全局常量( public static final )
final关键字:
1、final用于修饰属性、变量。
变量成为了常量，无法对其再次进行赋值。
final修饰的局部变量，只能赋值一次 (可以先声明后赋值)
final修饰的是成员属性，必须在声明时赋值。
常量的命名规范:
由1个或多个单词组成，单词与单词之 间必须使用下划线隔开，单词中所有字母大写。
例如: SQL_ INSERT
2、final用于修饰类：final修饰的类，不可以被继承。
3、final用于修饰方法：final修饰的方法，不能被子类重写。
抽象类：
如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类。（子类中如果有没有重写的父类方法，那么子类还是抽象类）
tips:
java中堆的作用：存放java对象实例
java虚拟机栈作用：存储java方法执行时的局部变量（基本类型数据和引用数据类型的引用）
方法区作用：存储已被虚拟机加载的类信息、
常量、静态变量等数据
程序计数器作用：实现异常处理，线程恢复等基础功能
5、抽象类
概念
抽象类必须使用abstract class声明
一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或者接口中。
// 抽象类格式：
abstract class 类名{
}
抽象方法
只声明而未实现的方法称为抽象方法（未实现指的是：没有“{}”方法体），抽象方法必须使用abstract关
键字声明。
格式：
abstract class 类名{ // 抽象类
public abstract void 方法名() ; // 抽象方法，只声明而未实现
}
不能被实例化
在抽象类的使用中有几个原则：
抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须覆写(重写)抽象类中的全
部抽象方法。
常见问题
1、 抽象类能否使用final声明？
不能，因为final属修饰的类是不能有子类的 ， 而抽象类必须有子类才有意义，所以不能。
2、 抽象类能否有构造方法？
能有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类中的
构造方法（默认是无参的），之后再调用子类自己的构造方法。
抽象类和普通类的区别
1、抽象类必须用public或procted 修饰(如果为private修饰，那么子类则无法继承，也就无法实现其
抽象方法）。默认缺省为 public
2、抽象类不可以使用new关键字创建对象， 但是在子类创建对象时， 抽象父类也会被JVM实例化。
3、如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必
须定义为 abstract类
6、接口
概念
如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。
定义格式：
interface 接口名称{
全局常量 ;
抽象方法 ;
}
面向接口编程思想
这种思想是接口是定义（规范，约束）与实现（名实分离的原则）的分离。
优点：
1、 降低程序的耦合性
2、 易于程序的扩展
3、 有利于程序的维护
全局常量和抽象方法的简写
因为接口本身都是由全局常量和抽象方法组成 ， 所以接口中的成员定义可以简写：
1、全局常量编写时， 可以省略public static final 关键字，例如：
public static final String INFO = “内容” ;
简写后：
String INFO = “内容” ;
2、抽象方法编写时， 可以省略 public abstract 关键字， 例如：
public abstract void print() ;
简写后：
void print() ;
接口的实现 implements
接口可以多实现：
格式：
class 子类 implements 父接口1,父接口2…{
}
以上的代码称为接口的实现。那么如果一个类即要实现接口，又要继承抽象类的话，则按照以下的格式编写
即可：
class 子类 extends 父类 implements 父接口1,父接口2…{
}
接口的继承
接口因为都是抽象部分， 不存在具体的实现， 所以允许多继承,例如：
interface C extends A,B{
}
注意
如果一个接口要想使用，必须依靠子类。 子类（如果不是抽象类的话）要实现接口中的所有抽象方法。
接口和抽象类的区别
1、抽象类要被子类继承，接口要被类实现。
2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
4、抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现
5、抽象类中可以包含static方法 ，但是接口中不允许（静态方法不能被子类重写，因此接口中不能声明
静态方法）
6、接口不能有构造方法，但是抽象类可以有
7、多态
多态概念：是对象的多种表现形式，（多种体现形态）
多态的体现：
对象的多态性，从概念上非常好理解，在类中有子类和父类之分，子类就是父类的一种形态 ，对象多态性就从此而来。
ps: 方法的重载 和 重写 也是多态的一种， 不过是方法的多态（相同方法名的多种形态）。
重载： 一个类中方法的多态性体现
重写： 子父类中方法的多态性体现
多态的使用：对象的类型转换
类似于基本数据类型的转换：
· 向上转型：将子类实例变为父类实例
|- 格式：父类 父类对象 = 子类实例 ；
· 向下转型：将父类实例变为子类实例
|- 格式：子类 子类对象 = （子类）父类实例 ；
public static void main(String[] args) {
Student a = new Student();
Nurse b = new Nurse();
Person p1 = a;//可以以说学生是人(向上转型(
Person p2 = b;
p1.say();
p2.say();
Student a2 = (Student)p1;//说这个人是学生，必须加强转, (向下转型)
Student a3 = (Student)p2;//不能说护士是学生
a2.say();
a3.say();
}
8、instanceof
作用：
判断某个对象是否是指定类的实例，则可以使用instanceof关键字
格式：
实例化对象 instanceof 类 //此操作返回boolean类型的数据
9、Object类
Object类是所有类的父类（基类），如果一个类没有明确的继承某一个具体的类，则将默认继承Object
类。
例如我们定义一个类：
public class Person{
}
其实它被使用时 是这样的：
public class Person extends Object{
}
public class Demo1 {
public static void main(String[] args) {
String text = "123" ;
say(text);
int a=10;
say(a) ;
}
public static void say(Object o) {
System. out . println(o);
}
}
Object的多态
使用Object可以接收任意的引用数据类型
toString
建议重写Object中的toString方法。 此方法的作用：返回对象的字符串表示形式。
Object的toString方法， 返回对象的内存地址
equals
建议重写Object中的equals(Object obj)方法，此方法的作用：指示某个其他对象是否“等于”此对
象。
Object的equals方法：实现了对象上最具区别的可能等价关系; 也就是说，对于任何非空引用值x和
y ，当且仅当x和y引用同一对象（ x == y具有值true ）时，此方法返回true 。
equals方法重写时的五个特性：
自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。
对称性 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报
true 。
传递性 ：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true
，然后x.equals(z)应该返回true 。
一致性 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，前
提是未修改对象上的equals比较中使用的信息。
非空性 ：对于任何非空的参考值x ， x.equals(null)应该返回false 。
使用Equals比较两个对象是否相同：
public boolean equals(object o) {
if(this == o) {
return true;
}
if(o == nu11) {
return false;
}
if(o instanceof Person) {
Person p2 = (Person) o;
if(this.name.equals(p2.name) && this.age == p2.age) {
//相同
return true;
}else {
return false;
}
}else {
return false;
}
}
每日一练：
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
static关键字的特点和访问限制
被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。并且不会因为对象的多次创建 而在内存中建立多份数据
访问限制： 静态不能访问非静态 , 非静态可以访问静态 !
抽象类和接口的区别:
1、抽象类要被子类继承，接口要被类实现。
2、接口只能声明抽象方法，抽象类中可以声明抽象方法，也可以写非抽象方法。
3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
4、抽象类使用继承来使用， 无法多继承。 接口使用实现来使用， 可以多实现
5、抽象类中可以包含static方法 ，但是接口中不允许（因为静态方法不能被子类重写，因此接口中不能声明静态方法）
6、接口不能有构造方法，但是抽象类可以有
多态的概念，前提是什么
就是对象的多种表现形式，（多种体现形态）,前提是继承
递归图解
84
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
