Java-SE Day5
继承
子类可继承父类所有的public 方法/属性
在Java 中，所有的类，都默认直接或间接继承Object 类
java 类中只有单继承，没有多继承，只能继承一个父类（无法继承多个）
私有的东西（方法/类）无法被继承
// 继承一个类，关键字extends
public class Student extends Person{
private String name = “test”;
protected String name1 = "11"; // protected ： 受保护的
public void test(String name){
System.out.println(name); // 方法形参传入的name
System.out.println(this.name); // Student 类中定义的属性
System.out.println(super.name); // Person 类中定义的属性，父类中的属性/方法
}
}
super 注意点：
1. super 调用父类的构造方法，必须在构造方法的第一个（默认都会调用父子类的构造方法）
2. super 必须只能出现在子类的方法或者构造方法中！
3. super 和 this 不能同时调用构造方法！
Vs this :
代表的对象不同：
this ： 本身调用者这个对象
super ： 代表父类对象的应用
前提：
this ： 没有继承者也可以使用
super ： 只能在继承条件才能使用
构造方法：
this（）； 本类的构造
super() : 父类的构造
方法重写
重写都是方法的重写，与属性无关；子类与父类名称返回传参等都一致，但子类重写构建方法体
父类的引用可以指向子类
静态方法和非静态的方法区别很大
静态方法： 方法的调用之和左边，定义的数据类型有关
如：// test 方法都为静态
A a = new A（）;
a.test(); // 正常调用子类中的test 方法
B b = new A();
b.test(); // 静态方法以左边为准，即B（父类）
非静态：重写
静态方法无法重写，调用时以左边为主，非静态重写时以右边为主
重写：需要继承关系，子类重写父类的方法
1. 方法名相同
2. 参数列表相同
3. 修饰符：范围可以扩大但不能缩小： public > protected > default >private
4. 抛出的异常：范围，可以被缩小，但不能扩大;
Alt + Insert; override;
多态
一个对象的实际类型时确定的
对象能执行哪些方法，主要看对象左边的类型，和右边关系不大（右边用于重写父类）
// 可以指向的引用类型不确定：父类的引用指向子类
Person s2 = new Student(); // 父类的引用指向子类
/*
多态注意事项：
1. 多态是方法的多态，属性没有多态
2. 父类和子类，有联系 类型转换异常! ClassCastException !
3. 存在关系 ： 继承关系，方法需要重写，父类引用指向子类！ Father f1 = new Son();
无法重写：
1. static 方法，其属于类，不属于实例
2. final 常量
3. private 方法；
*/
多态：同一方法可根据发送对象的不同而采用多种不同的行为方式，典型的有方法重写和方法重载
instanceof 和类型转换
instanceof（类型转换）引用类型，判断一个对象是什么类型;
对象 instanceof 对象2 # 判断两个类是否有关系，返回boolean
无论是父类转子类还是子类转父类，转换过后能使用的方法只有其类中的方法
当然子类已经继承了父类中的方法，所以可以看作所有的方法
子类转父类可能会丢失方法
高转低需强转，低转高无需强转
// 高 低
Person obj = new Studenr(); // 对象为Person 类，但new Student 后会对方法重写
// Person 中无go 方法，无法使用，强转为Student 类，可调用Student 类中方法
Student obj1 = (Student) obj; // Person 对象强转为Student类的对象
static 关键字详解
静态会随着类的创建而创建，非静态是随着对象的创建而创建
private static int age; // 静态变量
private double score; // 非静态变量
Student student1 = new Student();
student1.score; // 可以调用，随着对象创建存在
Student.score; // 无法调用，随着类的创建存在
匿名代码块会默认执行，执行顺序高于构造器
被 final (常量) 关键字定义的类，无法被继承
{
System.out.prtinln("匿名代码块");
}
static {
System.out.println("静态匿名代码块");
}
public Student(){
System.out.println("构造器");
}
静态匿名代码块只会执行一次，在new 对象时匿名代码块会执行;
抽象类
抽象类的所有方法，继承其的子类必须实现其方法，除非子类也是抽象类
abstract 关键字用于定义抽象类
public abstract class Action{ // 定义抽象类。抽象方法必须存在抽象类中
public abstract void doSometing(); // abstract 定义方法后，此方法必须由子类重写后才可使用
}
- 不能new 抽象类，只能靠子类去实现它：约束
- 抽象类中可以写普通方法
- 抽象方法必须在抽象类中
接口
普通类：只有具体实现
抽象类： 具体实现和规范（抽象方法）都有 !
接口：只有规范！自己无法写方法
接口关键字定义不再时class 而是interface
接口中所有的定义其实都是抽象的 public abstract
接口可继承多个，而类只能单继承
public interface UserService{ // 创建接口且指定接口类
void add(String name); // 创建接口，
void del(String name);
public abstract void query(String name); // 接口中默认都存在public abstract,可省略
void update(String name);
}
// 子类重写接口方法
public class UserServiceImpl implements UserService{} // 子类继承接口
作用：
1. 约束
2. 定义一些方法，让不同的人实现 10 ---> 1 # 多个接口由一个子类多继承重写实现其功能
3. public abstract # void add(); 接口类中默认已经存在public abstract 关键字
4. public static final # 接口中定义常量变量（不常用）
5. 接口不能被实例化。 接口中没有构造方法 # 接口于抽象类相似，作为其的延申，abstract 只是定义方法，不会在此类中直接实现方法，需由子类实现
6. implement 可以实现多继承多个接口 # 子类继承接口的关键字 implement
7. 必须要重写接口中的方法 # 子类一旦继承就需要重写接口中定义的方法
总结 ： 接口属于抽象类的延申，都是先对方法名进行定义，后由子类进行方法的重写，唯一最大的区别在于：接口可以被多继承，从而实现java 无法被多继承;
N种内部类
内部类就是在一个类的内部再定义一个类
内部类可以获得外部类的私有方法/属性
一个Java类/文件 中可以由多个class 类，但只能有一个public class 类
Outer outer = new Outer(); // 正常实例化类
Outer.Inner inner = outer.new Inner(); // 通过实例化后的对象进行实例化内部类
inner.getId(); // 调用内部类方法
// 局部内部类
public void method(){ // 方法中定义类，仅存在于此方法中
class Inner{ // 不推荐如此使用
public void in(){}
}
}
浙公网安备 33010602011771号