黑马程序员_Java面向对象2

------- android培训、java培训、期待与您交流！ ----------

Java面向对象2

一：文档制作

1.如果在一个类A中，使用另外的一个类B的内容。

方式1：先编译B类，在编译A类。最后使用A类。

方式2：直接编译A类，它会自动帮你编译B类。

2.代码体现

/**
*这是一个操作数组的工具类，它里面有遍历及获取最值得功能。
*@author fanchenghao
*@version V1.0
*/

/*
javadoc: 错误 - 找不到可以文档化的公共或受保护的类。
         这个错误表示该类的访问权限不够。
         所以，就直接加一个public

格式：javadoc -d doc -author -version ArrayTools.java
*/

public class ArrayTools {
       private ArrayTools(){}

       /**
        *这是对数组遍历的方法。
        *@param int[] arr就是要被遍历的数组
        */
       public static void printArray(int[] arr) {
              for(int x=0; x<arr.length; x++) {
                      System.out.println(arr[x]);
              }
       }

       /**
        *这是对数组获取最大值的方法
        *@param int[] arr就是要被获取最值的数组
        *@return int 返回数组中的最大值
        */
        public static int getMax(int[] arr) {
               int max = arr[0];

               for(int x=1; x<arr.length; x++) {

                       if(arr[x]>max) {
                              max = arr[x];
                       }
               }

               return max;
        }
}

二：Math类

1.如何使用JDK提供的API(应用程序编程接口--帮助文档)。以Math举例。
步骤：
(1).找到文档，打开文档。

(2).点击左上角的显示变成隐藏，然后点击索引

(3).你应该知道你要找谁?Math,所以，你就在那个输入框里面输入Math，然后回车，再回车。

(4).看这个类的结构

java.lang

         类 Math

java.util

         类 Scanner

如果是java.lang包下的类，是可以直接使用的。(Math)

否则，就需要导包才能使用。(Scanner)

(5).看看对这个类的说明。

(6).看构造方法

名称：字段--成员变量--属性。

A.有构造方法，那么，就通过构造方法创建对象使用。

B.没有构造方法，那么，这个类的成员一般都是静态。通过类名调用。

(7).按照正常的操作使用方法。

左边：

      是否静态：如果静态修饰，那么可以通过类名调用。否则，就必须创建对象调用。

      是否有明确返回值：如果是void类型，就直接调用即可。否则，就可以输出或者赋值。

右边：

      看方法名：不要写错了。

      看参数：看参数类型及个数。

2.代码体现Math中需要掌握的功能

class MathDemo {

      public static void main(String[] args) {
             //成员常量
             System.out.println(Math.E);
             System.out.println(Math.PI);

             //成员方法
             //绝对值
             System.out.println(Math.abs(-12));

             //大于等于参数的最小整数,返回类型是double
             System.out.println(Math.ceil(12.3));
             System.out.println(Math.ceil(12.7));

             //小于等于参数的最大整数,返回类型是double
             System.out.println(Math.floor(12.3));
             System.out.println(Math.floor(12.7));

             //四舍五入的
             System.out.println(Math.round(12.3f));
             System.out.println(Math.round(12.7f));

             //随机数
             System.out.println(Math.random());

             //两个数中的最大值,最小值自学。
             System.out.println(Math.max(12,23));
             //三个数中的最大值,12,23,18
             System.out.println(Math.max(Math.max(12,23),18));
      }
}

三：Random类

1.构造方法：

           Random():使用默认种子。当前时间的毫秒值。每次产生的随机数都是变化的。

           random(long seed):如果给定了种子，每次都是按照种子做出初始值产生的随机数，如果种子固定，值是一样的。

2.成员方法：

           int nextInt():int范围内的一个数据

           int nextInt(int n):在0到n范围内的一个数据，包括0，不包括n。

3.代码体现

import java.util.Random;

class RandomDemo {
      public static void main(String[] args) {
             //创建对象
             Random r = new Random();

              for(int x=0; x<10; x++) {

                     int num = r.nextInt(100);
                     System.out.println(num);
             }
      }
}

四：继承

1.思路：

首先先写两个类：Student,Teacher

class Student {
        private String name;
        private int age;

        public Student(){}

        public void setName(String name) {
               this.name = name;
        }

        public String getName() {
               return name;
        }

        ...

}

class Teacher {
       private String name;
       private int age;

       public Teacher(){}

       public void setName(String name) {
              this.name = name;
       }

       public String getName() {
              return name;

       }

       ...
}

这个时候，发现了一个问题，假如将来有很多这样的类似的类，那么，代码的重复度是很高的。
这样，有效代码其实并不多。

我们就这样思考：

假如能够把这些类中的相同的内容给提取出来定义在某一个类中，
然后，让其他的类和这个定义的类产生一个关系，有了这个关系，
他们就都具备了这个定义类中的功能。该有多好呢?

针对这种情况，java就提供了一种技术：继承。

如果采用继承技术，怎么体现现在的代码呢?
继承的格式：
class 类A extends 类B {

}

//这就表示类A继承了类B。

class Person {

      private String name;

      private int age;

      public Person(){}

      public void setName(String name) {
             this.name = name;

      }

      public String getName() {
             return name;
      }

      ...
}

class Student extends Person {

}

class Teacher extends Person {

}

叫法：
     Person：父类，基类，超类。
     Student,Teacher：子类，派生类。

注意:子类可以直接访问父类中的非私有的属性和行为。

2.继承的好处:

(1).提高了代码的复用性。

(2).让类与类之间产生了一个关系，是多态的前提。

3.继承的特点:

(1).Java只支持单继承，不支持多继承。

    为什么呢?因为如何可以多继承，就会出现调用不明确的问题。

(2).Java支持多层(重)继承(继承体系)

4.什么时候把类的关系定义为继承呢?

  由于继承体现了一种关系：is a的关系。xxx is yyy的一种。

  以后，在定义类(A,B)的时候：

  如果他们有关系：A is a B 的一种。或者B is a A。

  那么，他们之间就存在继承关系。前者A是子类，后者B是子类。

  注意：不要为了获取部分功能，而去使用继承。

5.研究子父类的成员变量的关系?

通过子类访问一个成员变量的时候：
(1).首先在局部范围找，如果有就使用。
(2).继续在成员位置找，如果有就使用。
(3).最后在父类中找，如果有就使用。
(4).如果找不到就报错。

我现在要在子类中，输出局部范围的值，输出成员范围的值，输出父亲成员变量的值,该怎么办?

(1).局部范围的值  直接输出变量名即可。

(2).成员范围  输出this.变量名即可。

(3).父的成员变量  输出super.变量名即可。

6.super关键字：和this的用法很像,super代表父类的内存空间的标识。(可以理解为父亲的对象引用)

7.this和super的使用：
(1).成员变量：

        this.变量--当前类的变量
        super.变量--父类的变量

(2).构造方法：用在构造方法中的。

        this(参数)--本类的构造方法
        super(参数)--父类的构造方法

(3).成员方法：

        this.方法名()--本类的方法
        super.方法名()-- 父类的方法

8.子父类的成员方法调用? 先找子类，在找父亲。

  子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

9.方法重写和方法重载的区别?

方法重写：

            子父类中，出现方法相同的情况。返回值，方法名，参数。

方法重载:

            同一个类中，方法名相同，参数列表不同。跟返回值无关。

10.子父类方法重写的注意问题:

(1).父类中的私有方法不可以被重写。
(2).子类方法访问权限一定要大于等于父类方法访问权限。

(3).静态的方法只能被静态方法重写。这个其实不能算对象的关系。

(4).覆盖的应用：

              当子类需要父类的功能，而功能主体子类有自己特有内容时，

              可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

11.继承中的构造关系:

(1).子类的构造方法默认都去访问了父类的无参构造方法

    在子类中的构造方法中都有一行默认语句:super()

(2).为什么要这样呢?

    因为子类会自动具备父类中非私有数据，那么，这个数据的初始化靠父类完成。

    所以，会去先调用父类的构造方法对数据进行初始化。

(3).注意：

如果父类中没有无参构造方法，那么，该怎么办呢?

A.可以通过super(参数)去访问父类中的带参构造方法。

B.可以通过this(参数...)去访问本类中的其他构造方法。不推荐使用。

五：静态代码块和构造代码块

1.执行顺序：静态代码块 -- > 构造代码块 -- > 构造方法。

2.注意：静态代码块只执行一次。

3.代码体现

class Fu {
      //静态代码块
      static {
             System.out.println("Fu 静态代码块");
      }

      //构造代码块

      {
             System.out.println("Fu 构造代码块");

      }

      public Fu() {
             System.out.println("Fu 构造方法");
      }
}

class Zi extends Fu {
        //静态代码块
        static {
               System.out.println("zi 静态代码块");
        }

        //构造代码块

        {

               System.out.println("zi 构造代码块");
        }

        public Zi() {
               System.out.println("zi 构造方法");
        }
}

class BlockCodeDemo {
        public static void main(String[] args) {
               Zi z = new Zi();
               Zi z2 = new Zi();

        }
}

4.如何成员变量被私有了，那么，在子类中怎么使用呢?

(1).儿子通过父亲的set方法可以给父亲的成员变量赋值。

(2).通过子类调用父类的带参构造方法。

六：final关键字

很多时候，有些内容，是不能被子类重写的。而我们又知道，只要方法声明(public void show())相同。

子类就可以重写父类方法。这样就让父类的方法不安全了。 

针对这种情况，我们如果能够做一个标记，告诉别人，注意了，这个方法是不可以被重写了。

那么，这个标记是什么呢?final

1.final关键字：最终的意思。它可以修饰类，修饰成员变量，修饰成员方法。

               它修饰的类不能被继承。

               它修饰的成员方法，是不可以被子类重写的。

               它修饰的成员变量，其实是一个常量。
2.常量：

       字面值常量 'a',"hello",123

       定义常量和定义变量的格式一致，不过，加了final修饰。

七：总结

1.如何使用API

(1).找到文档，打开文档。

(2).点击左上角的显示变成隐藏，然后点击索引。

(3).你应该知道你要找谁?Math

    所以，你就在那个输入框里面输入Math，然后回车，再回车。
(4).看这个类的结构
java.lang
         类 Math
java.util

         类 Scanner

如果是java.lang包下的类，是可以直接使用的。(Math)

否则，就需要导包才能使用。(Scanner)

(5).看看对这个类的说明。

(6).看构造方法

名称：字段--成员变量--属性。

A.有构造方法，那么，就通过构造方法创建对象使用。

B.没有构造方法，那么，这个类的成员一般都是静态。通过类名调用。

(7).按照正常的操作使用方法。
左边：
    是否静态：如果静态修饰，那么可以通过类名调用。否则，就必须创建对象调用。

    是否有明确返回值：如果是void类型，就直接调用即可。否则，就可以输出或者赋值。
右边：

    看方法名：不要写错了。
    看参数：看参数类型及个数。

2.继承
(1).把多个类中的相同的属性和行为进行抽取，封装到一个类中，

    然后再建立新类的时候，不需要从头做起，继承刚才定义的那个类即可。

(2).好处：

A:提高代码的复用性。

B:让类与类之间产生了一个关系，是多态的前提。

(3).什么时候使用继承?

A:如果类之间存在着:is a 的关系，就可以考虑使用继承。

B:不要为了继承部分功能，而去使用继承。

(4).继承的特点:

A:Java只支持单继承，不支持多继承。

  为什么?如果支持多继承，就会有调用不明确的问题。

B:Java支持多层(重)继承。

(5).super和this的区别?

A.super是一个关键字，代表父类的存储空间标识。(可以理解为父亲的引用)

B.它和this的用法相似

a.成员变量

         this.变量--本类的
         super.变量--父类的

b.构造方法

         this(...)--本类的

         super(...)--父类的

c.成员方法

         this.方法名()--本类的
         super.方法名()--父类的

(6).子父类中成员变量的用法：
A.名称不同，这个太简单了。

B.名称相同，子类对象的在使用的时候：

  先找子类局部范围

  再找子类成员范围

  最后找父类成员范围

(7).子父类中成员方法的用法：

A.名称不同，这个太简单了。

B.名称相同，子类对象的在使用的时候：

  先找子类的
  再找父类的

C.方法重写

  在子类中，方法声明(修饰符,返回值,方法名,参数列表)相同的情况。

  注意事项：

  a.父类中私有方法是不能被重写

  b.子类方法的访问权限一定要大于等于父类的访问权限
  c.静态只能重写静态。(这个不能算，因为静态跟类相关)

(8).子父类中构造方法的用法：
A.子类的初始化过程中，首先回去执行父类的初始化动作。
  因为子类的构造方法中默认有一个super()。
  为什么?子类要使用父类的成员变量，这个初始化，必须在子类初始化之前完成。

  所以，子类的初始化过程中，会先执行父类的初始化。

B.如果父类没有无参构造方法
  a.使用super调用父类的带参构造。推荐方式。
  b.使用this调用本身的其他构造。

3.代码块
(1).执行顺序：
静态代码块 --> 构造代码块 --> 构造方法

(2).注意事项：
静态代码块只执行一次


4.final

(1).是一个关键字，可以用于修饰类，成员变量，成员方法。

(2).特点:

        它修饰的类不能被继承。
        它修饰的成员变量是一个常量。
        它修饰的成员方法是不能被子类重写的。