JAVA学习四：面向对象高级（1）

1.1继承格式
class 父类{
}
class 子类 extends 父类{
}
1.2 限制

Java中只有单继承，多重继承，没有多继承。
一个子类只能有一个父类。
当A类要继承B和C的关系，那么B可以继承C,A可以继承B
C–B--A，多重继承。

1.3子类实例化内存分析

创建子类对象之前，先查看子类对象有哪些父类，
先创建父类对象，然后再在内存中创建子类对象空间，
子类对象中有一个super属性变量 = 父类对象的地址。
可以将父类对象看成子类对象的一部分。

实例：
父类：Person
子类：Student
Student s = new Student();
s.setName(“tom”);当调用这段代码时。
先找Student有没有setName的方法，发现没有，
就去super里去找Person，如果没有再去Person的父类中找。
所以内存代码为：
Student.super.setName(“tom”);
最终的name设置给了Person；

总结：当我们创建子类对象时，先创建父类对象然后创建自己
并且父类对象会作为子类对象中的super存在。
所谓的继承只是子类拥有了一个父类的地址而已。

1.4 super关键字详解

通过super，可以访问父类构造方法
调用super构造方法的代码，必须写在子类构造方法的第一行。
通过super，可以访问父类的属性
通过super，可以访问父类的方法

调用构造方法：
如果父类没有无参构造方法，则需要明确通过super访问父类的构造方法。若需要通过子类的无参构造方法访问父类的有参构造方法也可以。
class Student extends Person{
public Student() {
super(“默认”,1);//此处调用了父类的全参构造方法，旨在new新对象时给对象默认赋值。
}
}

调用父类属性
super.name = “tom”;
等于new Student().new Person().name = “tom”;
子类 父类 父类属性

访问父类方法
super.setName(“tom”);
等于new Student().new Person().setName = “tom”;
子类 父类 父类方法

1.5重写，与重载的区别

重写（override）规则：
1.参数列表必须完全与被重写方法的相同；
2.返回类型必须完全与被重写方法的返回类型相同；
3.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果一个父类的方法被声明为public，那么子类中重写该方法不能比public低。
4.父类的成员方法只能被它的子类重写
5.声明为static和private的方法不能被重写，但是能够被再次声明。

面试题
java中重写override与重载overload的区别
1.发生的位置
重载：一个类中
重写：子父类中
2.参数列表限制
重载：必须不同
重写：必须相同
3.返回值类型
重载：与返回值类型无关
重写：返回值类型必须相同
4.访问权限：
重载：与访问权限无关
重写：子的访问权限必须不能小于父类的方法权限
5.异常处理：
重载：与异常无关
重写：异常范围可以更小，但是不能抛出新的异常
1.6 final关键字

final用于修饰属性、变量。

变量成为了常量，无法再次进行赋值。
final修饰局部变量只能赋值一次，可以先声明后赋值。
final修饰成员属性，必须在声明时对其赋值。

全局常量：public static final
常量的命名规范：
由1个或多个单词组成，单词与单词之间必须使用_隔开，单词中所有字母大写。例如：SQL_INSERT

final用于修饰类。

final修饰的类，不可以被继承。

final用于修饰方法。

final修饰的方法，不能被子类重写。

1.7抽象类

为什么会有抽象类

当一个父类有许多子类，它们的方法都不一样，在创建父类时无法确定方法该如何实现时，可以使用抽象类创建父类。

概念：
必须使用abstract class声明
一个抽象类中可以没有抽象方法。抽象方法必须写在抽象类或接口中。
格式：
abstract class 类名{//抽象类
}

抽象方法：
只声明而未实现的方法称为抽象方法（未实现指的是 没有{}方法体）
抽象方法必须用abstract关键字声明。
格式：
abstract class 类名{
public abstract void 方法名() ;
}

不能被实例化
在抽象类的使用中有几个原则：
抽象类本身是不能直接进行实例化操作的，即：不能直接使用关键字new完成。
一个抽象类必须被子类所继承，被继承的子类（如果不是抽象类）则必须重写抽象类中的全部抽象方法。

1.8抽象类常见问题

1.抽象类不能使用final声明，抽象类必须拥有子类。

2.抽象类是否能有构造方法？

能够有构造方法，而且子类对象实例化的时候的流程与普通类的继承是一样的，都是要先调用父类的构造方法（默认无参），之后再调用子类的构造方法。

3.抽象类和普通类的区别
抽象类必须使用public或protected（如果为private修饰，那么子类无法继承，也就无法实现其抽象方法）。默认缺省为public。

抽象类不可以使用new关键字创建对象，但是在子类创建对象时，抽象父类也会被JVM实例化。

如果一个子类继承抽象类，那么必须实现其所有的抽象方法。如果有未实现的抽象方法，那么子类也必须定义为abstract类。

1.9接口
概念
如果一个类中的全部方法都是抽象方法，全部属性都是全局常量，那么此时就可以将这个类定义成一个接口。
格式
interface 接口名称{
全局常量；
抽象方法；
}

面向接口编程思想
这种思想是接口是定义（规范约束）与实现（名实分离的原则）的分离。

全局常量和抽象方法的简写

因为接口本身都是由全局常量和抽象方法组成，所以可以简写
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.接口不能有构造方法，但是抽象类可以有。

1.10多态

概念
多态：就是对象的多种表现形式，多种体现形态。
多态的体现
父类引用指向子类对象。
父类的对象名称 = 子类对象；p = s；
这时就可以说s是p的一种形态。

多态的使用：对象的类型转换
类似于基本数据类型的转换：
向上转型：将子类实例变为父类实例
格式：父类 父类对象 = 子类实例；
向下转型：将父类实例变为子类实例
格式：子类 子类对象 = （子类）父类实例；

应用场景
Student s = new Student();
say(s);
Nurse n = new Nurse();
say(n);
//此时学生和护士都继承了抽象类Person，它们作为参数传入say方法都可以运行，当新增子类时，say方法的具体逻辑就不用更改了。
public static void say(Person p){
p.say();
}