ToB企服应用市场:ToB评测及商务社交产业平台

标题: day11-面向对象02 [打印本页]

---

作者: 魏晓东    时间: 2022-9-4 19:53
标题: day11-面向对象02
面向对象02

7.继承

• 继承的本质是对某一批类的抽象，从而实现对现实世界更好地建模
  
• extends的意思是“扩展”。子类是父类的扩展。
  
• Java类中只有单继承，没有多继承！（一个儿子只能有一个爸爸，一个爸爸可以有多个儿子）
  
• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
  
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends表示
  
• 子类和父类之间，从意义上讲应该具有“is a”的关系
  
• object类
  
• super
  
• 方法重写
  

子类继承了父类，就会有父类的全部方法！（私有的东西无法被继承）

例子1：

1. package li.oop.demo05;
3. //父类：Person 人
4. public class Person {
6.     //public
7.     //protected
8.     //default
9.     //private
10.     public int money = 10_0000_0000;
12.     public void say(){
13.         System.out.println("说了一句话");
14.     }
16.     public int getMoney() {
17.         return money;
18.     }
20.     public void setMoney(int money) {
21.         this.money = money;
22.     }
23. }

复制代码

1. package li.oop.demo05;
2. //学生 is 人
3. //派生类（子类）,子类继承了父类，就会有父类的全部方法
4. public class Student extends Person{
6. }

复制代码

1. package li.oop;
3. import li.oop.demo05.Student;
5. public class Application {
6.     public static void main(String[] args) {
7.         Student student = new Student();
8.         student.say();//说了一句话
9.         System.out.println(student.money);// 1000000000
10.     }
12. }

复制代码

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：

1. package li.oop.demo05;
2. //重写都是方法的重写，和属性无关
3. public class B {
4.     public static void test(){
5.         System.out.println("B==>test");
6.     }
7. }

复制代码

1. package li.oop.demo05;
2. public class A extends B{
4.     public static void test(){
5.         System.out.println("A==>test");
6.     }
7. }

复制代码

1. package li.oop;
3. import li.oop.demo05.A;
4. import li.oop.demo05.B;
6. public class Application {
7.     public static void main(String[] args) {
8.        //静态方法：方法的调用只和左边定义的类型有关
9.        A a = new A();
10.        a.test();//调用的是A类方法
12.        //父类的引用指向了子类
13.        B b = new A();
14.        b.test();//调用的是B类方法
16.     }
17. }

复制代码

静态方法：方法的调用只和左边定义的类型有关

例子2：

1. package li.oop.demo05;
2. //重写都是方法的重写，和属性无关
3. public class B {
4.     public  void test(){
5.         System.out.println("B==>test");
6.     }
7. }

复制代码

1. package li.oop.demo05;
3. public class A extends B{
4.     //Override  重写
5.     @Override // 注解：有功能的注解！
6.     public void test(){
7.         System.out.println("A==>test");
8.     }
9. }

复制代码

1. package li.oop;
2. import li.oop.demo05.A;
3. import li.oop.demo05.B;
5. //静态方法和非静态方法区别很大！
6. //静态方法：方法的调用只和左边定义的类型有关
7. //非静态：重写
8. public class Application {
9.     public static void main(String[] args) {
11.        A a = new A();
12.        a.test();
14.        //父类的引用指向了子类
15.        B b = new A();//子类重写了父类的方法
16.        b.test();
17.     }
18. }

复制代码

总结：
重写  ：子类的方法和父类的方法必须要一致，方法体不同
--    重写前提：需要有继承关系，子类重写父类的方法

• 方法名必须相同
  
• 参数列表必须相同
  
• 修饰符：范围可扩大，但不能缩小：public>protected>default>private
  
• 抛出的异常：范围可以被缩小，但不能扩大。例如：ClassNotFoundException（范围小）-->Exception(范围大)
  

为什么需要重写？：父类的功能，子类不一定需要，或者不一定满足！
快捷键：Alt+insert：Override；
8.多态

8.1多态的定义和使用

• 即同一方法可以根据发送对象的不同而采取多种不同的行为方式
  
• 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多
  

  这里的引用一般指父类或者有关系的类
  

  
  
• 多态存在的条件：
  
  
  
  • 有继承关系
    
  • 子类重写父类方法
    
  • 父类引用指向子类对象
    
  
  
• 注意：多态是方法的多态，属性没有多态性
  
• instanceof    （类型转换）引用类型
  

例子1：

1. package li.oop.demo06;
3. public class Person {
4.     public void run(){
5.         System.out.println("run");
6.     }
7. }

复制代码

1. package li.oop.demo06;
3. public class Student extends Person{
5. }

复制代码

1. package li.oop;
3. import li.oop.demo06.Person;
4. import li.oop.demo06.Student;
6. public class Application {
7.     public static void main(String[] args) {
9.         //一个对象的实际类型是确定的
10.         //new Student();
11.         //new Person();
13.         //但是可以指向的引用类型就不确定了
14.         Student s1 = new Student();
15.         Person s2 = new Student();//父类的引用指向子类
16.         Object s3 = new Student();//父类的引用指向子类
18.         s2.run();//这里虽然new的是Student，但是是它依旧走的是父类的方法，因为子类继承了父类的全部方法
19.     }
20. }

复制代码

这里的 s2 虽然new的是Student，但是是s2.run() 依旧走的是父类的方法，因为子类继承了父类的全部方法

例子2

1. package li.oop.demo06;
3. public class Person {
4.     public void run(){
5.         System.out.println("run");
6.     }
7. }

复制代码

1. package li.oop.demo06;
3. public class Student extends Person{
4.     @Override
5.     public void run() {
6.         System.out.println("son");
7.     }
9.     public void eat(){
10.         System.out.println("eat");
11.     }
12. }

复制代码

1. package li.oop;
3. import li.oop.demo06.Person;
4. import li.oop.demo06.Student;
6. public class Application {
7.     public static void main(String[] args) {
9.         //一个对象的实际类型是确定的
10.         //new Student();
11.         //new Person();
12.         //但是可以指向的引用类型就不确定了
14.         //Sudent能调用的方法都是自己的或者继承父类的
15.         Student s1 = new Student();
17.         //Person父类型：可以指向子类，但是不能调用子类独有的方法
18.         Person s2 = new Student();//父类的引用指向子类
19.         Object s3 = new Student();//父类的引用指向子类
21.         s2.run();//子类重写了父类的方法,执行子类的方法
22.         s1.run();
24.         //s2.eat 不能调用  s2为Person父类型：可以指向子类，但是不能调用子类独有的方法
25.         ((Student) s2).eat();//强制类型转换后才可以使用
26.         //对象能够执行的方法主要看对象左边的类型和右边关系不大
27.     }
29. }

复制代码

对象能够执行的方法主要看对象左边的类型和右边关系不大
如
//Person父类型：可以指向子类，但是不能调用子类独有的方法
Person s2 = new Student();//父类的引用指向子类
//子类Sudent能调用的方法都是自己的或者继承父类的
Student s1 = new Student();
多态注意事项：

• 多态是方法的多态，属性没有多态
  
• 父类和子类，有联系
  
• 多态存在的必要条件：
  
  
  
  • 有继承关系
    
  • 方法需要重写
    
    
    
    • 不能重写的方法：
      
      
      
      • 1.static 方法，属于类，它不属于实例
        
      • final 常量
        
      • private 方法
        
      
      
    
    
  • 父类的引用指向子类对象
    
  
  

8.2instanceof

instanceof(类型转换)引用类型，判断一个对象是什么类型

例子1：

1. package li.oop.demo06;
3. public class Person {
4.     public void run(){
5.         System.out.println("run");
6.     }
7. }

复制代码

1. package li.oop.demo06;
3. public class Student extends Person{
5. }

复制代码

1. package li.oop.demo06;
2. public class Teacher extends Person{
3. }

复制代码

1. package li.oop;
3. import li.oop.demo06.Person;
4. import li.oop.demo06.Student;
5. import li.oop.demo06.Teacher;
7. public class Application {
8.     public static void main(String[] args) {
10.         //Object > Person > Student
11.         //Object > Person > Teacher
12.         //Object > String
14.         Object object = new Student();
15.         System.out.println(object instanceof Student);//true
16.         System.out.println(object instanceof Person);//true
17.         System.out.println(object instanceof Object);//true
18.         System.out.println(object instanceof Teacher);//false
19.         System.out.println(object instanceof String);//false
21.         System.out.println("==============");
23.         Person person = new Student();
24.         System.out.println(person instanceof Student);//true
25.         System.out.println(person instanceof Person);//true
26.         System.out.println(person instanceof Object);//true
27.         System.out.println(person instanceof Teacher);//false
28.        // 编译就报错了 System.out.println(person instanceof String);
30.         System.out.println("==============");
32.         Student student = new Student();
33.         System.out.println(student instanceof Student);//true
34.         System.out.println(student instanceof Person);//true
35.         System.out.println(student instanceof Object);//true
36.         // 编译就报错了 System.out.println(student instanceof Teacher);
37.         //编译就报错了 System.out.println(student instanceof String);
39.     }
40. }

复制代码

总结：
System.out.println(X instanceof Y);
能不能编译通过，取决于X与Y之间是否存在直系继承关系
8.3类的类型转换

• 基本类型转换
  
  
  
  • 高容量转换成低容量：强制类型转换
    
  • 低容量转换成高容量：自动类型转换
    
  
  
• 类之间的转化：父类代表高的，子类代表低的
  
  
  
  • 父转子：强制转换
    
  • 子转父：自动转换
    
  
  

例子：

1. package li.oop.demo06;
3. public class Person {
4.    
5. }

复制代码

1. package li.oop.demo06;
3. public class Student extends Person{
4.     public void go(){
5.         System.out.println("go");
6.     }
7. }

复制代码

1. package li.oop;
2. import li.oop.demo06.Person;
3. import li.oop.demo06.Student;
5. public class Application {
6.     public static void main(String[] args) {
8.         /*类型之间的转换：
9.          1.基本类型转换-->高容量转换成低容量：强制类型转换
10.                        低容量转换成高容量：自动类型转换
11.          2.类之间的转化：父类代表高的，子类代表低的
12.          */
14.         //高   <--- ---- ---     低
15.         Person student = new Student();
17.         //这里只有在子类Student类中才有go（）方法，
18.         // 而student对象是Person类型的，因此不能直接调用，需要强制类型转换成子类类型才能使用go（）方法
19.         //高   --- ---- --- >    低
20.         ((Student) student).go();//go
22.         //或者
23.         Person obj = new Student();
24.         Student student1 = (Student) obj;//强制转换
25.         student1.go();//go
28.         /*
29.         子类转换成父类可能会丢失自己本来的一些方法
30.          */
31.         Student student2 = new Student();
32.         student2.go();//go
33.         Person person = student2;//自动转换 低-->高
34.        //这里的 person对象就不能使用原本子类的go()方法了
36.     }
37. }

复制代码

总结：

• 父类的引用指向子类的对象（子类的引用不能指向父类的对象）
  
• 把子类转换为父类，向上转型（自动类型转换）
  
• 把父类转换为子类，向下转型（强制转换）
  

  基本数据类型的强制转换可能会丢失精度，类的强制转换可能会丢失一些方法
  

  
  
• 为什么会存在类的类型转换？方便方法的调用，减少重复代码，更简洁
  

9.static关键字详解

9.1静态变量和静态方法

例子1：静态变量尽量使用类名来访问

1. package li.oop.demo07;
3. //static
4. public class Student {
5.     private static int age;//静态的变量
6.     private double score;//非静态的变量
8.     public static void main(String[] args) {
9.         Student s1 = new Student();
11.         //1.静态变量尽量使用类名来访问
12.         //通过类来使用
13.         System.out.println(Student.age);//0
14.         //通过对象来使用
15.         System.out.println(s1.age);//0
16.         System.out.println(s1.score);//0.0
18.     }
20. }

复制代码

例子2：静态方法

• 调用非静态方法需要通过实例对象来调用
  
• 调用静态方法可以直接通过类调用，如果如果静态方法和main方法在同一个类中，甚至可以直接调用
  
• 非静态方法可以去调用静态方法里的所有东西，而静态方法不能调非静态方法
  

1. package li.oop.demo07;
3. //static
4. public class Student {
5.     private static int age;//静态的变量
6.     private double score;//非静态的变量
9.     public  void run(){
10.         System.out.println("run");
11.     }
12.     public static void go(){
13.         System.out.println("go");
14.     }
16.     public static void main(String[] args) {
17.         
18.        //2.静态方法
19.         //调用非静态方法需要通过实例对象来调用
20.         Student s2 = new Student();
21.         s2.run();
23.         //调用静态方法可以直接通过类调用，如果如果静态方法和main方法在同一个类中，甚至可以直接调用
24.         Student.go();
25.         go();
26.         
27.          //3.非静态方法可以去调用静态方法里的所有东西，而静态方法不能调非静态方法
28.         //比如在静态方法main()中不能直接调用非静态方法run()
30.     }
31. }

复制代码

9.2静态代码块

1. package li.oop.demo07;
3. public class Person {
4.     {
5.         //代码块（匿名代码块）
6.     }
8.     static{
9.         //静态代码块
10.     }
12. }

复制代码

• 如上所示，在类中用大括号括起来的一段没有名字的代码块称为匿名代码块。在括号前加上static关键字的代码块称为静态代码块。
  
• 匿名代码块没有名字，程序在执行时并不能主动去调用这些模块。在创建对象的时候匿名代码块自动创建，并且在构造器之前
  
• 静态代码块是类加载的同时就直接执行，永久只执行一次
  

例子：匿名代码块、静态代码块、构造方法的加载顺序

1. package li.oop.demo07;
3. public class Person {
4.     {
5.         System.out.println("匿名代码块");//代码块（匿名代码块）
6.     }
8.     static{
9.         System.out.println("静态代码块");//静态代码块
10.     }
12.     public Person() {
13.         System.out.println("构造方法");
14.     }
16.     public static void main(String[] args) {
17.         
18.         System.out.println("==========111");
19.         Person person1 = new Person();
21.         System.out.println("==========222");
22.         Person person2 = new Person();
24.     }
25. }

复制代码

加载顺序：
静态代码块>匿名代码块>构造函数
静态代码块在person1实例化前就执行了，静态代码块是在类加载的同时就执行了，并且只执行一次
9.3静态导入包

1. package li.oop.demo07;
3. //静态导入包~
4. import static java.lang.Math.random;
5. import static java.lang.Math.PI;
7. public class Test {
8.     public static void main(String[] args) {
9.         System.out.println(random());
10.         System.out.println(PI);
11.     }
12. }

复制代码

PS：被final修饰的类不能被其他类继承

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4