（二）面向对象编程（OOP）
1、封装
作用：
- 提高程序的安全性，保护数据；
- 隐藏代码的实现细节；
- 统一接口；
- 系统的可维护增加了
2、继承
在Java中，所有的类，都默认直接或者间接继承object类；
快捷键：
Ctrl+H；可查看各个继承关系
修饰符四种：public、private、protected、default（默认）
//在java中年，所有的类，都默认直接或者间接继承Object类
//人 ： 父类
public class Person {
//public：公共
//protected：受保护
//default：默认的修饰符
//private：私有
private int money = 10_0000_0000;
public void say(){
System.out.println("我说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
//学生 is 人：派生类，子类
//资料继承了父类，就拥有了父类的全部方法
public class Student extends Person{
//Ctrl + H
}
//测试类
public class Applicantion {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.getMoney());
}
}
super注意点：
- super调用父类的构造方法，必须在构造方法的第一个；
- super必须只能出现在子类的方法或者构造方法中！
- super和 this 不能同时调用构造方法！
Vs this：
-
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
-
前提：
this：没有继承也可以使用
super：只能在继承条件才可以使用
-
构造方法
this()：本类的构造
super()：父类的构造！
//在java中年，所有的类，都默认直接或者间接继承Object类
//人 ： 父类
public class Person {
// 快捷键 ：Alt + Insert
public Person() {
System.out.println("Person无参执行了");
}
protected String name = "qinyin";
//私有的东西无法被继承
public void print(){
System.out.println("Person");
}
}
//学生 is 人：派生类，子类
//资料继承了父类，就拥有了父类的全部方法
public class Student extends Person{
public Student() {
//隐藏代码：调用了父类的无参构造
super();//调用父类的构造器，必须在子类构造器的第一行
System.out.println("Student无参执行了");
}
private String name = "xueqin";
public void print(){
System.out.println("Student");
}
public void test(String name){
print(); //Student
this.print();//Student
super.print();//Person
System.out.println(name); //学琴
System.out.println(this.name);//xueqin
System.out.println(super.name);//qinyin
}
}
//测试类
public class Applicantion {
public static void main(String[] args) {
Student student = new Student();
student.test("学琴");
}
}
重写 ：需要有继承关系，子类重写父类的方法！
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但不能缩小：public>Protected>Default>private
4. 抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException -->Exception(大)
重写，子类的方法和父类必须要一致：方法体不同！
为什么需要重写：
-
父类的功能，子类不一定需要，或者不一定满足！
Alt + Insert ：override；
//重写但是方法的重写，跟属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
//继承B
public class A extends B{
//Override 重写
@Override //注解：有功能的注释
public void test() {
System.out.println("A=>test()");
}
}
//测试类
public class Applicantion {
//静态的方法和非静态的方法区别很大！
//静态方法：方法的调用只和左边，定义的数据类型有关
//非静态：重写
public static void main(String[] args) {
A a = new A();
a.test(); //A
//父类的引用指向了子类
B b = new A(); //子类重写了父类的方法
b.test(); //B
}
}
3、多态
//person父类
public class Person {
public void run(){
System.out.println("run");
}
}
//Student子类
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
//测试类
public class Applicantion {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了：父类的引用指向子类
//子类Student 能调用的方法都是自己的或者继承父类的！
Student s1 = new Student();
//父类Person，可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();
Object s3 = new Student();
//对象能执行那些方法，主要看对象左边的类型，和右边关系不大！
((Student) s2).eat();
s2.run();//子类重写了父类的方法，执行子类的方法
s1.run();
}
}
多态注意事项：
-
多态是方法的多态，属性没有多态
-
父类和子类，有联系 类型转换异常！ClassCastException！
-
存在条件：继承关系，方法需要重写，父类引用指向子类对象！
Father f1 = new Son();
-
有些方法是不能被重写的：
-
static 方法，属于类，它不属于实例；
-
final 常量；
-
private 方法；
-
instanceof
public class Applicantion {
public static void main(String[] args) {
//Object > Person > Student
//Object > Person > Teacher
//Object > String
Object object = new Student();
// System.out.println(X instanceof Y); //能不能编译通过！
System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //false
System.out.println(object instanceof String); //false
System.out.println("--------------------");
Person person = new Student(); //降级
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //false
// System.out.println(person instanceof String); //编译报错！
System.out.println("--------------------");
Student student = new Student();
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
// System.out.println(student instanceof Teacher); //编译报错！
// System.out.println(student instanceof String); //编译报错！
}
}
类型转换
public static void main(String[] args) {
//类型之间的转换：父（高） 子（低）
//高转低：强制类型转换
Person obj = new Student();
//obj将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
((Student) obj).go();
//低转高，自动类型转换，必须满足两个条件：
//1.必须有继承关系
//2.低类型必须转换为高类型
Student stu = new Student();
stu.go();
Person obj2 = stu;
//子类转换为父类，可能丢失自己本来的一些方法！
//obj2.go(); //报错！
}
- 父类引用指向子类的对象
- 把子类转换为父类，向上转型；
- 把父类转换为子类，向下转型；强制转换，可能会丢失方法
- 方便方法的调用，减少重复的代码！简洁
抽象：封装、继承、多态！
抽象类，接口
