day11-面向对象02
面向对象02
7.继承
- 继承的本质是对某一批类的抽象,从而实现对现实世界更好地建模
- extends的意思是“扩展”。子类是父类的扩展。
- Java类中只有单继承,没有多继承!(一个儿子只能有一个爸爸,一个爸爸可以有多个儿子)
- 继承是类和类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。
- 继承关系的两个类,一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends表示
- 子类和父类之间,从意义上讲应该具有“is a”的关系
- object类
- super
- 方法重写
子类继承了父类,就会有父类的全部方法!(私有的东西无法被继承)
例子1:
package li.oop.demo05;
//父类:Person 人
public class Person {
//public
//protected
//default
//private
public int money = 10_0000_0000;
public void say(){
System.out.println("说了一句话");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
package li.oop.demo05;
//学生 is 人
//派生类(子类),子类继承了父类,就会有父类的全部方法
public class Student extends Person{
}
package li.oop;
import li.oop.demo05.Student;
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();//说了一句话
System.out.println(student.money);// 1000000000
}
}
7.1Object类
在Java中,所有的类都默认直接或者间接继承Object类
7.2Super关键字
-
super. 大部分情况下是可以省略的。
当父中类有,子类中又有,如果想在子中访问“父的特征”,super. 不能省略。
在父和子中有同名的属性,或者说有相同的方法,如果此时想在子类中访问父中的数据,必须使用“super.”加以区分。-
super.属性名 —>访问父类的属性
-
super.方法名(实参) —>访问父类的方法
-
super(实参) —->调用父类的构造方法
-
-
子类继承父类,子类的构造方法必须调用super()即父类的构造方法,而且必须放在构造方法的第一行。
子类构造方法第一行都有调用父类无参的构造方法,如果你不显示地写出了,系统会自己加上;
但是如果你的父类重载了一个或多个构造方法,系统将不再默认加上无参的构造方法,必须自己加上。
- super调用父类的构造方法,必须在构造方法中的第一行
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
- super&&this
- 代表的对象不同:
- this:代表本身调用者这个对象
- 代表当前类的父类对象的引用
- 前提:
- this:没有继承也可以使用
- super:只能在继承条件下才可以使用
- 构造方法的区别:
- this(); 本类的构造
- super(); 父类的构造
- 代表的对象不同:
7.3方法重写
例子1:
package li.oop.demo05;
//重写都是方法的重写,和属性无关
public class B {
public static void test(){
System.out.println("B==>test");
}
}
package li.oop.demo05;
public class A extends B{
public static void test(){
System.out.println("A==>test");
}
}
package li.oop;
import li.oop.demo05.A;
import li.oop.demo05.B;
public class Application {
public static void main(String[] args) {
//静态方法:方法的调用只和左边定义的类型有关
A a = new A();
a.test();//调用的是A类方法
//父类的引用指向了子类
B b = new A();
b.test();//调用的是B类方法
}
}
静态方法:方法的调用只和左边定义的类型有关
例子2:
package li.oop.demo05;
//重写都是方法的重写,和属性无关
public class B {
public void test(){
System.out.println("B==>test");
}
}
package li.oop.demo05;
public class A extends B{
//Override 重写
@Override // 注解:有功能的注解!
public void test(){
System.out.println("A==>test");
}
}
package li.oop;
import li.oop.demo05.A;
import li.oop.demo05.B;
//静态方法和非静态方法区别很大!
//静态方法:方法的调用只和左边定义的类型有关
//非静态:重写
public class Application {
public static void main(String[] args) {
A a = new A();
a.test();
//父类的引用指向了子类
B b = new A();//子类重写了父类的方法
b.test();
}
}
总结:
重写 :子类的方法和父类的方法必须要一致,方法体不同
— 重写前提:需要有继承关系,子类重写父类的方法
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可扩大,但不能缩小:public>protected>default>private
- 抛出的异常:范围可以被缩小,但不能扩大。例如:ClassNotFoundException(范围小)–>Exception(范围大)
为什么需要重写?:父类的功能,子类不一定需要,或者不一定满足!
快捷键:Alt+insert:Override;
8.多态
8.1多态的定义和使用
-
即同一方法可以根据发送对象的不同而采取多种不同的行为方式
-
一个对象的实际类型是确定的,但可以指向对象的引用类型有很多
这里的引用一般指父类或者有关系的类
-
多态存在的条件:
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
-
注意:多态是方法的多态,属性没有多态性
-
instanceof (类型转换)引用类型
例子1:
package li.oop.demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package li.oop.demo06;
public class Student extends Person{
}
package li.oop;
import li.oop.demo06.Person;
import li.oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//但是可以指向的引用类型就不确定了
Student s1 = new Student();
Person s2 = new Student();//父类的引用指向子类
Object s3 = new Student();//父类的引用指向子类
s2.run();//这里虽然new的是Student,但是是它依旧走的是父类的方法,因为子类继承了父类的全部方法
}
}
这里的 s2 虽然new的是Student,但是是s2.run() 依旧走的是父类的方法,因为子类继承了父类的全部方法
例子2
package li.oop.demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package li.oop.demo06;
public class Student extends Person{
@Override
public void run() {
System.out.println("son");
}
public void eat(){
System.out.println("eat");
}
}
package li.oop;
import li.oop.demo06.Person;
import li.oop.demo06.Student;
public class Application {
public static void main(String[] args) {
//一个对象的实际类型是确定的
//new Student();
//new Person();
//但是可以指向的引用类型就不确定了
//Sudent能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
//Person父类型:可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student();//父类的引用指向子类
Object s3 = new Student();//父类的引用指向子类
s2.run();//子类重写了父类的方法,执行子类的方法
s1.run();
//s2.eat 不能调用 s2为Person父类型:可以指向子类,但是不能调用子类独有的方法
((Student) s2).eat();//强制类型转换后才可以使用
//对象能够执行的方法主要看对象左边的类型和右边关系不大
}
}
对象能够执行的方法主要看对象左边的类型和右边关系不大
如
//Person父类型:可以指向子类,但是不能调用子类独有的方法
Person s2 = new Student();//父类的引用指向子类
//子类Sudent能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
多态注意事项:
- 多态是方法的多态,属性没有多态
- 父类和子类,有联系
- 多态存在的必要条件:
- 有继承关系
- 方法需要重写
- 不能重写的方法:
- 1.static 方法,属于类,它不属于实例
- final 常量
- private 方法
- 不能重写的方法:
- 父类的引用指向子类对象
8.2instanceof
instanceof(类型转换)引用类型,判断一个对象是什么类型
例子1:
package li.oop.demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package li.oop.demo06;
public class Student extends Person{
}
package li.oop.demo06;
public class Teacher extends Person{
}
package li.oop;
import li.oop.demo06.Person;
import li.oop.demo06.Student;
import li.oop.demo06.Teacher;
public class Application {
public static void main(String[] args) {
//Object > Person > Student
//Object > Person > Teacher
//Object > String
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);//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);
}
}
总结:
System.out.println(X instanceof Y);
能不能编译通过,取决于X与Y之间是否存在直系继承关系
8.3类的类型转换
- 基本类型转换
- 高容量转换成低容量:强制类型转换
- 低容量转换成高容量:自动类型转换
- 类之间的转化:父类代表高的,子类代表低的
- 父转子:强制转换
- 子转父:自动转换
例子:
package li.oop.demo06;
public class Person {
}
package li.oop.demo06;
public class Student extends Person{
public void go(){
System.out.println("go");
}
}
package li.oop;
import li.oop.demo06.Person;
import li.oop.demo06.Student;
public class Application {
public static void main(String[] args) {
/*类型之间的转换:
1.基本类型转换-->高容量转换成低容量:强制类型转换
低容量转换成高容量:自动类型转换
2.类之间的转化:父类代表高的,子类代表低的
*/
//高 <--- ---- --- 低
Person student = new Student();
//这里只有在子类Student类中才有go()方法,
// 而student对象是Person类型的,因此不能直接调用,需要强制类型转换成子类类型才能使用go()方法
//高 --- ---- --- > 低
((Student) student).go();//go
//或者
Person obj = new Student();
Student student1 = (Student) obj;//强制转换
student1.go();//go
/*
子类转换成父类可能会丢失自己本来的一些方法
*/
Student student2 = new Student();
student2.go();//go
Person person = student2;//自动转换 低-->高
//这里的 person对象就不能使用原本子类的go()方法了
}
}
总结:
-
父类的引用指向子类的对象(子类的引用不能指向父类的对象)
-
把子类转换为父类,向上转型(自动类型转换)
-
把父类转换为子类,向下转型(强制转换)
基本数据类型的强制转换可能会丢失精度,类的强制转换可能会丢失一些方法
-
为什么会存在类的类型转换?方便方法的调用,减少重复代码,更简洁
9.static关键字详解
9.1静态变量和静态方法
例子1:静态变量尽量使用类名来访问
package li.oop.demo07;
//static
public class Student {
private static int age;//静态的变量
private double score;//非静态的变量
public static void main(String[] args) {
Student s1 = new Student();
//1.静态变量尽量使用类名来访问
//通过类来使用
System.out.println(Student.age);//0
//通过对象来使用
System.out.println(s1.age);//0
System.out.println(s1.score);//0.0
}
}
例子2:静态方法
-
调用非静态方法需要通过实例对象来调用
-
调用静态方法可以直接通过类调用,如果如果静态方法和main方法在同一个类中,甚至可以直接调用
-
非静态方法可以去调用静态方法里的所有东西,而静态方法不能调非静态方法
package li.oop.demo07;
//static
public class Student {
private static int age;//静态的变量
private double score;//非静态的变量
public void run(){
System.out.println("run");
}
public static void go(){
System.out.println("go");
}
public static void main(String[] args) {
//2.静态方法
//调用非静态方法需要通过实例对象来调用
Student s2 = new Student();
s2.run();
//调用静态方法可以直接通过类调用,如果如果静态方法和main方法在同一个类中,甚至可以直接调用
Student.go();
go();
//3.非静态方法可以去调用静态方法里的所有东西,而静态方法不能调非静态方法
//比如在静态方法main()中不能直接调用非静态方法run()
}
}
9.2静态代码块
package li.oop.demo07;
public class Person {
{
//代码块(匿名代码块)
}
static{
//静态代码块
}
}
-
如上所示,在类中用大括号括起来的一段没有名字的代码块称为匿名代码块。在括号前加上static关键字的代码块称为静态代码块。
-
匿名代码块没有名字,程序在执行时并不能主动去调用这些模块。在创建对象的时候匿名代码块自动创建,并且在构造器之前
-
静态代码块是类加载的同时就直接执行,永久只执行一次
例子:匿名代码块、静态代码块、构造方法的加载顺序
package li.oop.demo07;
public class Person {
{
System.out.println("匿名代码块");//代码块(匿名代码块)
}
static{
System.out.println("静态代码块");//静态代码块
}
public Person() {
System.out.println("构造方法");
}
public static void main(String[] args) {
System.out.println("==========111");
Person person1 = new Person();
System.out.println("==========222");
Person person2 = new Person();
}
}
加载顺序:
静态代码块>匿名代码块>构造函数
静态代码块在person1实例化前就执行了,静态代码块是在类加载的同时就执行了,并且只执行一次
9.3静态导入包
package li.oop.demo07;
//静态导入包~
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
PS:被final修饰的类不能被其他类继承