狂神说Java
面向对象11:方法重写
静态的方法和非静态的方法区别很大!
总结:
重写:需要有继承关系,子类重写父类的方法!
1、方法名必须相同
2、参数列表必须相同
3、修饰符:范围可以扩大但不能缩小:private—>public
public>protected>default>private
4、抛出的异常:范围可以被缩小,但不能扩大 ClassNotFoundException—>Exception(大)
重写,子类的方法和父类必须要一致,方法体不同
为什么需要重写:
1、父类的功能,子类不一定需要,或者不一定满足!
快捷键:
Alt + Insert : override
面向对象12:什么是多态
package oop.demo06;
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
package oop.demo06;
public class Person {
public void run()
{
System.out.println("run");
}
}
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
// new Student();
// new Person();
//可以指向的引用类型就不确定了:父类的引用指向子类
Student s1 = new Student();
Person s2 = new Student();
//对象能执行那些方法,主要看对象左边的类型,和右边关系不大
//Student 能调用的方法都是自己的或者继承父类的
//Person 父类型 ,可以指向子类,但是不能调用子类独有的方法
s2.run();//子类重写了父类的方法,执行子类的方法
s1.eat();
s1.run();
}
}
多态注意事项:
1、多态是方法的多态,属性没有多态
2、父类和子类,有联系 类型转换异常! ClassCastException
3、存在条件:继承关系,方法需要重写,父类引用指向子类对象!Father f1 = new Son();
不能被重写:
1、static 方法,属于类,它不属于实例
2、final 常量:
3、private 方法
多态:
即同一个方法可以根据发送对象的不同而采取多种不同的行为方法
一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多
面向对象13:instanceof和类型转换
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;
import java.util.Objects;
public class Application {
public static void main(String[] args) {
//Object > String
//Object > Person > Student
//Object > Person > Teacher
Object object = new Student();
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);//true
//System.out.println(person instanceof String);//编译报错
}
}
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
import oop.demo06.Teacher;
import java.util.Objects;
public class Application {
public static void main(String[] args) {
//Object > String
//Object > Person > Student
//Object > Person > Teacher
Object object = new Student();
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(x instanceof y);//能不能编译通过是看是否存在父子关系
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);//true
//System.out.println(person instanceof String);//编译报错
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);//编译报错
}
}
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//类型之间的转换 : 父 子
//高 低
Person obj = new Student();
//student 将这个对象转换为Student类型,就可以使用Student类型的方法了!
Student obj1 = (Student)obj;
obj1.go();
}
}
package oop;
import oop.demo06.Person;
import oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//类型之间的转换 : 父 子
//子类转换为父类,可能丢失自己的本来的一些方法
Student student = new Student();
student.go();
Person person = student;
}
}
总结:
1、父类引用指向子类的对象
2、把子类转换为父类,向上转型
3、把父类转换为子类,向下转型:强制转换
4、方便方法的调用,减少重复的代码,简介
抽象:封装、继承、多态
面向对象14:static关键字详解