方法重写
public class B {
public void test(){
System.out.println("B=>test()");
}
}
//重写都是方法的重写，与属性无关
public class A extends B{
//重写
@Override//注解：有功能的解释
public void test() {
System.out.println("A=>test");
}
}
//静态方法和非静态方法区别很大
public class ApplicationDemo07 {
public static void main(String[] args) {
//方法的调用只和左边定义的数据有关
A a=new A();
a.test();//A
//父亲的引用指向子类
B b = new A();//子类重写了父类的方法
b.test();//A
//如果不重写，使用static则输出B
}
}
多态
public class Person {
public void run(){
System.out.println("run");
}
}
/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父亲和子类，有联系 类型转换异常！ ClassCastExcepttion!
3.存在条件：继承关系， 方法需要重写，父类引用指向子类对象！Father f1=new Son();
一下不能重写
1.Static 方法，属于类，它不属于实例
2.final 常量
3.private方法
*/
public class Student extends Person {
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
import oop.Demo08.Person;
import oop.Demo08.Student;
public class ApplicationDemo08 {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//可以指向的引用类型就不确定了,父亲的引用指向子类
//Student能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
Person s2= new Student();
Object s3=new Student();
s2.run();//子类重写了父类的方法，执行子类的方法
s1.run();
//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
/* s2.eat();//报错，子类重写了父类的方法，执行子类的方法
*/
s1 .eat();
((Student) s2).eat();
}
}
instanceof(类型转换) 引用类型，判断一个对象是什么类型
public class Person {
public void run(){
System.out.println("run");
}
}
public class Teacher extends Person {
}
public class Student extends Person {
public void go(){
System.out.println("go");
}
}
import oop.Demo09.Person;标签：instanceof,System,Day10,Student,println,public,out From： https://www.cnblogs.com/xclxcl/p/16735767.html
import oop.Demo09.Student;
import oop.Demo09.Teacher;
/*
import oop.Demo09.Person1;
import oop.Demo09.Student;
import oop.Demo09.Teacher;
import org.omg.CORBA.Object;
*/
/**
* @author senko
* @date 2022/9/27 18:06
*/
public class ApplicationDemo09 {
public static void main(String[] args) {
//Object>String
//Object>Person>Teavher
//Object>Person>Student
Object object = new Student();
//System.out.println(X instanceof S); 编译能不能通过，看X与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 person1=new Student();
System.out.println(person1 instanceof Student);//true
System.out.println(person1 instanceof Person);//true
System.out.println(person1 instanceof Object);//true
System.out.println(person1 instanceof Teacher);//false
// System.out.println(person1 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);//编译错误
System.out.println("======================================");
//类型之间的转化： 父 子
//高----》低 高转低可能会导致父类的一些方法流失
Person obj=new Student();
//Student1将这个对象转换为Student类型，我们就可以使用Student类型的方法了
Student student1 = (Student) obj;
student1.go();//这两行可以直接写成((Student)obj).go();
//低----》高
Student student2 = new Student();
student2.go();
Person person=student;
}
}
/*
1.父类引用指向子类对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型，强制转换
4.方便方法调用，减少重复的代码！简洁
抽象：封装，继承，多态
*/