No_16_0229 Java基础学习第八天

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了No_16_0229 Java基础学习第八天相关的知识，希望对你有一定的参考价值。

文档版本 开发工具 测试平台 工程名字 日期 作者 备注
V1.0 2016.02.29 lutianfei none

工具类中使用静态
帮助文档的制作
如何使用帮助文档
Math类学习
代码块
继承
继承概述
继承的好处
Java中继承的特点
Java中继承的注意事项
什么时候使用继承呢?
继承中成员变量的关系
super关键字
继承中构造方法的关系
继承中成员方法的关系
方法重写概述
方法重写的注意事项
练习题

工具类中使用静态

  • 当报错无法从静态上下文中引用非静态 方法xxx：
    • 表明在静态方法中引用了非静态方法

  • 在工具类中当把构造方法私有后，外界就不能再创建对象了，此时将所有方法设为静态后。可以根据静态方法的特点：通过类名来调用。

  • Eg：

  1. /*
  2.     我想要对数组进行操作
  3.     在同一个文件夹下，类定义在两个文件中和定义在一个文件中其实一样的。
  4. */
  5. class ArrayDemo {
  6.     public static void main(String[] args) {
  7.         //定义数组
  8.         int[] arr = {28,55,37,46,19};
  10.         //静态方法
  11.         //printArray(arr);
  13.         //非静态方法
  14.         //ArrayDemo ad = new ArrayDemo();
  15.         //ad.printArray(arr);
  17.         //测试类的作用：创建其他类的对象，调用其他类的功能。
  18.         //而我们现在的操作是跟数组相关的，所以，你应该把这些操作定义到数组操作类中
  19.         //定义一个数组的操作类
  20.         //有了数组操作类之后的调用
  21.         //ArrayTool at = new ArrayTool();
  22.         //at.printArray(arr);
  24.         //方法改进为静态后，就可以直接通过类名调用
  25.         ArrayTool.printArray(arr);
  26.     }
  28.     /*
  29.     public static void printArray(int[] arr) {
  30.         for(int x=0; x<arr.length; x++) {
  31.             if(x == arr.length-1) {
  32.                 System.out.println(arr[x]);
  33.             }else {
  34.                 System.out.print(arr[x]+", ");
  35.             }
  36.         }
  37.     }
  38.     */
  40.     //假设该方法不是静态的
  41.     /*
  42.     public void printArray(int[] arr) {
  43.         for(int x=0; x<arr.length; x++) {
  44.             if(x == arr.length-1) {
  45.                 System.out.println(arr[x]);
  46.             }else {
  47.                 System.out.print(arr[x]+", ");
  48.             }
  49.         }
  50.     }
  51.     */
  52. }
  55. class ArrayTool {
  57.     //把构造方法私有，外界就不能在创建对象了
  58.     private ArrayTool(){}
  60.     public static void printArray(int[] arr) {
  61.         for(int x=0; x<arr.length; x++) {
  62.             if(x == arr.length-1) {
  63.                 System.out.println(arr[x]);
  64.             }else {
  65.                 System.out.print(arr[x]+", ");
  66.             }
  67.         }
  68.     }
  69. }

帮助文档的制作

  • 制作工具类
    • ArrayTools

  • 制作帮助文档(API)

    • javadoc -d 目录 -author -version ArrayTool.java
      • 目录可以写一个文件的路径

  • 制作帮助文档出错：

  • 找不到可以文档化的公共或受保护的类：告诉我们类的权限不够。修改方法在类前面加public修饰。

如何使用帮助文档

  • 点击显示，找到索引，出现输入框
  • 你应该知道你找谁?举例：Scanner
  • 看这个类的结构(需不需要导包) 注：java.lang包下的类不需要导入，其他的全部需要导入。
    • 成员变量 说明书中对照为字段摘要
    • 构造方法 说明书中对照为构造方法摘要
      • 有构造方法 ： 创建对象
      • 没有构造方法：成员可能都是静态的，通过类名调用。
    • 成员方法 方法摘要
      • 看左边
        • 是否静态：如果静态，可以通过类名调用
        • 返回值类型：定义返回的是说明，就用什么接收。
      • 看右边
        • 方法名，不要打错
        • 参数列表：需要什么参数，就给什么，需要几个给几个
    • 看版本说明
  • 看这个类的说明
    • 看构造方法
    • 看成员方法

Math类学习

  1. /*
  2.     Math:类包含用于执行基本数学运算的方法
  4.     由于Math类在java.lang包下，所以不需要导包。
  5.     特点：
  6.         没有构造方法，因为它的成员全部是静态的。
  8.     掌握一个方法：
  9.         获取随机数
  10.         public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
  11. */
  12. class MathDemo {
  13.     public static void main(String[] args) {
  14.         //获取一个随机数
  15.         //double d = Math.random();
  16.         //System.out.println(d);
  18.         //需求：我要获取一个1-100之间的随机数，肿么办?
  19.         for(int x=0; x<100; x++) {
  20.             int number = (int)(Math.random()*100)+1;
  21.             System.out.println(number);
  22.         }
  23.     }
  24. }

代码块

  • 在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)。
  • 局部代码块
    • 在方法中出现；限定变量生命周期，及早释放，提高内存利用率
  • 构造代码块
    • 在类中,方法外出现；
    • 多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。
      • 作用：可以把多个构造方法中的共同代码放到一起。

  • 静态代码块

    • 在类中方法外出现，加了static修饰
    • 在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且只执行一次。

  • eg1 :

  1. class Code {
  2.     static { //静态代码块
  3.         int a = 1000;
  4.         System.out.println(a);
  5.     }
  7.     //构造代码块
  8.     {
  9.         int x = 100;
  10.         System.out.println(x);
  11.     }
  13.     //构造方法
  14.     public Code(){
  15.         System.out.println("code");
  16.     }
  18.     //构造方法
  19.     public Code(int a){
  20.         System.out.println("code");
  21.     }
  23.     //构造代码块
  24.     {
  25.         int y = 200;
  26.         System.out.println(y);
  27.     }
  29.     //静态代码块
  30.     static {
  31.         int b = 2000;
  32.         System.out.println(b);
  33.     }
  34. }
  36. class CodeDemo {
  37.     public static void main(String[] args) {
  38.         //局部代码块
  39.         {
  40.             int x = 10;
  41.             System.out.println(x);
  42.         }
  43.         //找不到符号
  44.         //System.out.println(x);
  45.         {
  46.             int y = 20;
  47.             System.out.println(y);
  48.         }
  49.         System.out.println("---------------");
  51.         Code c = new Code();    
  52.         System.out.println("---------------");
  53.         Code c2 = new Code();
  54.         System.out.println("---------------");
  55.         Code c3 = new Code(1);
  56.     }
  57. }
  60. /*
  61. * 程序运行结果：
  62. 10
  63. 20
  64. ---------------
  65. 1000
  66. 2000
  67. 100
  68. 200
  69. code
  70. ---------------
  71. 100
  72. 200
  73. code
  74. ---------------
  75. 100
  76. 200
  77. code
  78. */


  • Eg2 :
  2. class Student {
  3.     static {
  4.         System.out.println("Student 静态代码块");
  5.     }
  7.     {
  8.         System.out.println("Student 构造代码块");
  9.     }
  11.     public Student() {
  12.         System.out.println("Student 构造方法");
  13.     }
  14. }
  16. class StudentDemo {
  17.     static {
  18.         System.out.println("林青霞都60了，我很伤心");
  19.     }
  21.     public static void main(String[] args) {
  22.         System.out.println("我是main方法");
  24.         Student s1 = new Student();
  25.         Student s2 = new Student();
  26.     }
  27. }
  29. /*
  30.     写程序的执行结果。
  32.     林青霞都60了，我很伤心
  33.     我是main方法
  34.     Student 静态代码块
  35.     Student 构造代码块
  36.     Student 构造方法
  37.     Student 构造代码块
  38.     Student 构造方法
  39. */


继承

继承概述

  • 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
  • 通过extends关键字可以实现类与类的继承
    • ** class 子类名 extends 父类名 {} **
  • 单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
  • 有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员。
  1. class Dad(){}
  2. class Son extends Dad {}


继承的好处

  • 提高了代码的复用性
    • 多个类相同的成员可以放到同一个类中
  • 提高了代码的维护性
    • 如果功能的代码需要修改，修改一处即可

  • 让类与类之间产生了关系，是多态的前提

    • 其实这也是继承的一个弊端：类的耦合性很强

  • 开发的原则：低耦合，高内聚

    • 耦合：类与类的关系。
    • 内聚：就是自己完成某件事情的能力。

Java中继承的特点

  • Java只支持单继承，不支持多继承。
    • 一个类只能有一个父类，不可以有多个父类。
      • class SubDemo extends Demo{} //ok
      • class SubDemo extends Demo1,Demo2…//error
  • Java支持多层继承(继承体系)
    • class A{}
    • class B extends A{}
    • class C extends B{}

Java中继承的注意事项

  • 子类只能继承父类所有非私有的成员(成员方法和成员变量)
    • 其实这也体现了继承的另一个弊端：打破了封装性
  • 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。

  • 不要为了部分功能而去继承

  • Eg1：

  1. class Father {
  2.     private int num = 10;
  3.     public int num2 = 20;
  5.     //私有方法，子类不能继承
  6.     private void method() {
  7.         System.out.println(num);
  8.         System.out.println(num2);
  9.     }
  11.     public void show() {
  12.         System.out.println(num);
  13.         System.out.println(num2);
  14.     }
  15. }
  17. class Son extends Father {
  18.     public void function() {
  19.         //num可以在Father中访问private
  20.         //System.out.println(num); //子类不能继承父类的私有成员变量
  21.         System.out.println(num2);
  22.     }
  23. }
  25. class ExtendsDemo3 {
  26.     public static void main(String[] args) {
  27.         // 创建对象
  28.         Son s = new Son();
  29.         //s.method(); //子类不能继承父类的私有成员方法
  30.         s.show();
  31.         s.function();
  32.     }
  33. }


什么时候使用继承呢?

  • 继承中类之间体现的是：”is a”的关系。
  • 假设法：如果有两个类A,B。只有他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。

继承中成员变量的关系

  • 案例演示
    • 子父类中同名和不同名的成员变量
  • 结论：
    • 在子类方法中访问一个变量
    • 首先在子类局部范围找
    • 然后在子类成员范围找
    • 最后在父类成员范围找(肯定不能访问到父类局部范围)
    • 如果还是没有就报错。(不考虑父亲的父亲…)
super关键字
  • super的用法和this很像
    • this代表本类对应的引用。
    • super代表父类存储空间的标识(可以理解为父类引用)
  • 用法(this和super均可如下使用)
    • 访问成员变量
      • this.成员变量
      • super.成员变量
    • 访问构造方法(子父类的构造方法问题讲)
      • this(…) :调用本类的构造方法
      • super(…)：调用父类的构造方法
    • 访问成员方法(子父类的成员方法问题讲)
      • this.成员方法()
      • super.成员方法()

继承中构造方法的关系

  • 子类中所有的构造方法默认都会访问父类中空参数的构造方法
    • 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
    • 每一个构造方法的第一条语句默认都是：super()
  1. class Father {
  2.     int age;
  4.     public Father() {
  5.         System.out.println("Father的无参构造方法");
  6.     }
  8.     public Father(String name) {
  9.         System.out.println("Father的带参构造方法");
  10.     }
  11. }
  13. class Son extends Father {
  14.     public Son() {
  15.         //super();//默认都会有的
  16.         System.out.println("Son的无参构造方法");
  17.     }
  19.     public Son(String name) {
  20.         //super();//默认都会有的
  21.         System.out.println("Son的带参构造方法");
  22.     }
  23. }    
  25. class ExtendsDemo6 {
  26.     public static void main(String[] args) {
  27.         //创建对象
  28.         Son s = new Son();
  29.         System.out.println("------------");
  30.         Son s2 = new Son("林青霞");
  31.     }
  32. }
  • 程序运行结果：
    技术分享


  • 如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢,如何解决？
    • 会报错
    • 解决办法：
      • A：在父类中加一个无参构造方法
      • B：通过使用super关键字去显示的调用父类的带参构造方法。
    • 子类中一定要有一个访问了父类的构造方法，否则父类数据就没有办法初始化。

  • 注：super(…)必须放在第一条语句上，否则就可能出现对父类的数据进行了多次初始化，所以必须放在第一条语句上面。

  • 一个类的初始化过程

    • 成员变量进行初始化
    • 默认初始化
    • 显示初始化
    • 构造方法初始化

  • A:一个类的静态代码块,构造代码块,构造方法的执行流程

    • 静态代码块 > 构造代码块 > 构造方法
  • B:静态的内容是随着类的加载而加载
    • 静态代码块的内容会优先执行
  • C:子类初始化之前先会进行父类的初始化


  • 练习1
  1. /*
  2.     看程序写结果：
  3.         A:成员变量    就近原则
  4.         B:this和super的问题
  5.             this访问本类的成员
  6.             super访问父类的成员
  7.         C:子类构造方法执行前默认先执行父类的无参构造方法
  8.         D:一个类的初始化过程
  9.             成员变量进行初始化
  10.                 默认初始化
  11.                 显示初始化
  12.                 构造方法初始化
  14.     结果：
  15.         fu
  16.         zi
  17.         30
  18.         20
  19.         10
  20. */
  21. class Fu{
  22.     public int num = 10;
  23.     public Fu(){
  24.         System.out.println("fu");
  25.     }
  26. }
  27. class Zi extends Fu{
  28.     public int num = 20;
  29.     public Zi(){
  30.         System.out.println("zi");
  31.     }
  32.     public void show(){
  33.         int num = 30;
  34.         System.out.println(num); //30
  35.         System.out.println(this.num); //20
  36.         System.out.println(super.num); //10
  37.     }
  38. }
  39. class ExtendsTest {
  40.     public static void main(String[] args) {
  41.         Zi z = new Zi();
  42.         z.show();
  43.


























以上是关于No_16_0229 Java基础学习第八天的主要内容，如果未能解决你的问题，请参考以下文章

java基础第八天_多线程

java基础第八天_多线程

IT十八掌作业_java基础第八天_多线程

IT十八掌作业_java基础第八天_多线程

Python学习第八天_异常

Java基础学习第八天