Java面向对象（四）

Java面向对象（四）


目录

• Java面向对象（四）
  
  
  
  • 
    
    
    
    • 十一、package 关键字（拓展）
      
      
      
      • 11.1 package 关键字的使用：
        
      • 11.2 包的作用：
        
      • 11.3 Java主要的包
        
      • 11.4 MVC设计模式
        
      
      
    • 十二、import 关键字
      
    • 十三、面向对象的特征之二：继承性
      
      
      
      • 13.1 继承性的好处：
        
      • 13.2 继承性的格式：
        
      • 13.3 Java中关于继承性的规定：
        
      • 13.4 注意：
        
      
      
    • 十四、方法的重写 (override/overwrite)
      
      
      
      • 14.1 方法重写的定义：
        
      • 14.2 方法重写的规定：
        
      
      
    • 十五、super 关键字
      
      
      
      • 15.1 super 的使用：
        
      • 15.2 super 调用属性和方法：
        
      • 15.3 super 调用构造器：
        
      • 15.4 this 和 super 的区别：
        
      • 15.5 子类对象实例化的全过程
        
      
      
    
    
  
  

十一、package 关键字（拓展）

11.1 package 关键字的使用：

• 为了更好的实现项目中类的管理，提供包的概念
  
• 使用 package 声明类或接口所属的包，声明在源文件的首行
  
• 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
  一般包通常用小写单词标识。通常使用所在公司域名的倒置：com.xxx.xxx
  
• 包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
  
• 补充：同一个包下，不能命名同名的接口、类。
  ​           不同的包下，可以命名同名的接口、类。
  
• 它的格式为： package 顶层包名.子包名 ;
  

11.2 包的作用：

• 包帮助管理大型软件系统；
  
• 将功能相近的类划分到同一个包中。比如：MVC的设计模式 ；
  
• 包可以包含类和子包，划分项目层次，便于管理；
  
• 解决类命名冲突的问题；
  
• 控制访问权限。
  

11.3 Java主要的包

• java.lang    ----包含一些 Java 语言的核心类，如String、Math、Integer、 System和 Thread，提供常用功能
  
• java.net     ----包含执行与网络相关的操作的类和接口。
  
• java.io        ----包含能提供多种输入/输出功能的类。
  
• java.util      ----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
  
• java.text    ----包含了一些java格式化相关的类
  
• java.sql      ----包含了java进行JDBC数据库编程的相关类/接口
  
• java.awt     ----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。 B/S C/S（已经不常用了）
  

11.4 MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。
这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。


十二、import 关键字

• 在源文件中显式的使用 import 结构导入指定包下的类、接口。
  
• 声明在包的声明和类的声明之间。
  
• 如果需要导入多个结构，则并列写出即可。
  
• 可以使用"xxx."的方式，表示可以导入xxx包下的所有结构*。
  
• 如果使用的类或接口是 java.lang 包下定义的，则可以省略 import 结构。
  
• 如果使用的类或接口是本包下定义的，则可以省略 import 结构。
  
• 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
  

1. //        例如：在 java.util 和 java.sql 包下都有 Date 的类
2. package ...
4. import java.util.*;
5.    
6. public class Test() {
7.     public static void main(String[] args){
8.         
9.         Date date = new Date();                // 使用的是 java.util 包下的类
10.                 java.sql.Date date1 = new java.sql.Date(1234L);        // 以全类名的方式显示
11.         
12.     }
13. }

复制代码

• 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入。
  
• import static：导入指定类或接口中的静态结构：属性或方法。
  

1. package com.xxx;
3. import static java.lang.System.*;        //注意导入的是该类或接口中的静态结构
4. import static java.lang.Math.*;
6. public class Test {
7.         public static void main(String[] args) {
8.        
9.                 //        System.out.println("hello!");可以写成
10.                
11.                 out.println("hello");
12.                
13.         //  long num = Math.round(123.434);
14.         
15.         long num = round(123.434);
16.         
17.         }
18. }

复制代码

十三、面向对象的特征之二：继承性

13.1 继承性的好处：

• 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中， 那么多个类无需再定义这些属性和行为，只要继承那个类即可。减少了代码的冗余，提高了代码的复用性；
  
• 便于功能的扩展；
  
• 为之后多态性的使用，提供了前提。
  

13.2 继承性的格式：

• class A extends B{}
  

A：子类、派生类、subclass
B：父类、超类、基类、superclass

• 体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
  

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。

• 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。
  子类和父类的关系，不同于子集和集合的关系。
  

13.3 Java中关于继承性的规定：

• Java只支持单继承和多层继承，不允许多重继承。
  
  
  
  • 一个类可以被多个子类继承。
    
  • Java中类的单继承性：一个类只能有一个父类。
    
  
  

• 子父类是相对的概念。
  
• 子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类。
  
• 子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。
  

13.4 注意：

• 如果没有显式的声明一个类的父类的话，则此类继承于 java.lang.Object 类
  
• 所有的 java 类（除 java.lang.Object 类之外）都直接或间接的继承于 java.lang.Object 类
  
• 意味着，所有的 java 类具有 java.lang.Object 类声明的功能。
  

十四、方法的重写 (override/overwrite)

14.1 方法重写的定义：

• 子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作。
  
• 重写以后，当创建子类对象以后，通过子类对象调用子父类中的同名同参数的方法时，实际执行的是子类重写父类的方法。
  

14.2 方法重写的规定：

1. //        方法的声明：
2.     权限修饰符  返回值类型  方法名(形参列表) throws 异常的类型{
3.                                         //方法体
4.         }
6. //        子类中的叫重写的方法，父类中的叫被重写的方法

复制代码

• 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同。
  
• 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符。
  特殊情况：子类不能重写父类中声明为private权限的方法。
  
• 返回值类型：
  
  
  
  • 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void。
    
  • 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类。
    
  • 父类被重写的方法的返回值类型是基本数据类型(比如：double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须也是double)。
    
  
  
• 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。
  
• 子类和父类中的同名同参数的方法要么都声明为非static的（即为重写）。
  要么都声明为static的，但不属于方法的重写。因为static方法是属于类的，子类无法覆盖父类的方法。
  

1. public class Person {
2.     public String name;
3.     public int age;
4.     public String getInfo() {
5.         return "Name: "+ name + "\n" +"age: "+ age;
6.     }
7. }
8. public class Student extends Person {
9.     public String school;
10.     public String getInfo() {                                         //重写方法
11.         return "Name: "+ name + "\nage: "+ age
12.                 + "\nschool: "+ school;
13.     }
14.     public static void main(String args[]){
15.         Student s1=new Student();
16.         s1.name="Bob";
17.         s1.age=20;
18.         s1.school="school2";
19.         System.out.println(s1.getInfo()); //Name:Bob age:20 school:school2
20.     }
21. }

复制代码

十五、super 关键字

15.1 super 的使用：

• super可用于访问父类中定义的属性。
  
• super可用于调用父类中定义的成员方法。
  
• super可用于在子类构造器中调用父类的构造器。
  

注意：

• 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员。
  
• super的追溯不仅限于直接父类。
  
• super 和 this 的用法相像，this 代表本类对象的引用，super代表父类的内存空间的标识。
  

15.2 super 调用属性和方法：

• 在子类的方法或构造器中，可以通过使用"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。
  但是，通常情况下，我们习惯省略"super."
  
• 特殊情况：当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
  
• 特殊情况：当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
  

15.3 super 调用构造器：

• 可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器。
  
• "super(形参列表)"的使用，必须声明在子类构造器的首行！所以，在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现。
  
• 在构造器的首行，没有显式的声明"this(形参列表)"或"super(形参列表)"，则默认调用的是父类中空参的构造器：super()。
  
• 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错。
  
• 在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器。
  

15.4 this 和 super 的区别：


15.5 子类对象实例化的全过程

• 从结果上来看：（继承性）
  

• 1. **子类继承父类以后，就获取了父类中声明的属性或方法。**

  复制代码
• 1. **创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。**

  复制代码

• 从过程上来看：
  

• 1. 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器， 直到调用了 java.lang.Object 类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。

  复制代码

• 明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。
  

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