java--面向对象（2）--黑马程序员

面向对象（2）

主要内容：《  构造方法、成员方法、static关键字、静态的成员方法、 static的注意事项 》

1 构造方法概述和格式

         1.构造：实例化一个对象；new

         2.方法：指的是某一个方法。

         构造方法：跟构造相关的方法：

         当我们"实例化"一个对象时，使用的语法：

                            Student stu = new Student();

         后边的一对小括号就意味着调用了某个方法，这个方法就叫：构造方法；

         我们之前都没有定义过构造方法，那时是系统自动为我们添加的；

 

         自己定义构造方法：

         语法要求：

         1.构造方法的"方法名"必须和"类名"相同；

         2.构造方法不能定义"返回值类型"，甚至是void；

构造方法的格式：

1.构造方法的方法名必须与类名相同；

2.不能定义返回值类型，甚至是void；

3.构造方法内部不能返回任何值。但可以写return;语句；表示：结束构造方法的执行

 1 class Student{
 2 
 3          //定义普通的方法：
 4 
 5          void show(){
 6 
 7          }
 8 
 9          //定义构造方法
10 
11          //如果我们程序员没有定义构造方法，编译器会自动为这个类添加一个构造方法：没有形参，里面什么都不做。
12 
13          //当我们实例化这个类对象时，虚拟机就会自动调用这个构造方法。
14 
15 /*       Student(){
16 
17          }
18 
19 */
20 
21          //我们可以自己定义一个构造方法，当再实例化这个类的对象时，将会调用这个构造方法。
22 
23          Student(){
24 
25                    System.out.println("你构造了一个Student......");
26 
27          }
28 
29 }
30 
31 class Demo {
32 
33          public static void main(String[] args)
34 
35          {
36 
37                    Student stu = new Student();
38 
39          }
40 
41 }

2 构造方法的作用

1.由于它是在实例化一个对象时，被调用。    一般它内部可以做一些"初始化"的工作，和其它一些"先期的准备工作"。

2.理解构造方法的作用：

         给了我们一个机会，在实例化一个类对象之前，如果想做什么事情，就可以将代码写在"构造方法"里。这个方法每当实例化一个此类对象时，会被调用.

class Student{

         String name;

         int age;

         char sex;

//定义一个构造方法，做一些初始化的操作。这个构造方法将会在每次实例化这个对象时被调用；
Student(){
        name = "";
        age = 20;
        sex = '男';
        System.out.println("构造了一个Student对象......");
    }
}
class Demo {
    public static void main(String[] args) {
        Student stu = new Student();
        System.out.println(stu.name);
        System.out.println(stu.age);
        System.out.println(stu.sex);
        Student stu2 = new Student();
        Student stu3 = new Student();
        Student stu4 = new Student();
        Student stu5 = new Student();
    }
    }

3  构造方法的重载及注意事项)—

构造方法的注意事项：

1.如果我们不定义构造方法，系统添加一个：无参，什么都不做；

         2.如果我们定义了构造方法，那么系统将不再添加无参构造方法了；

         3.构造方法也是可以"重载"：

 

         构造方法重载的作用：

         1.意味着这个类，可以使用多种方式构造；方便使用者来构造对象；

         2.当我们实例化一个对象时，只能调用一个构造方法；其它构造方法将不会被调用；

　　　3.构造方法重载，实际上为这个类提供了一定的"灵活度"；

class Student
{
    private String name;
    private int age;
    private char sex;

    //构造方法时可以进行重载的；
    Student(){
        System.out.println("无参的构造方法......");
    }
    Student(int n){
        System.out.println("int的构造方法...... n = " + n);
    }
    Student(String name){
        System.out.println("String的构造方法...... name = " + name);
    }
//全参的构造方法
    Student(String name,int age ,char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
//提供一些get和set方法
    void setName(String name){
        this.name = name;
    }
    String getName(){
        return this.name;
    }
    void setAge(int age){
        this.age = age;
    }
    int getAge(){
        return this.age;
    }
    void setSex(char sex){
        this.sex = sex;
    }
    char getSex(){
        return this.sex;
    }
}
class Demo {
    public static void main(String[] args) {
        //调用无参的构造方法；
    //    Student stu = new Student();
        //调用int参数的构造方法
    //    Student stu2 = new Student(20);//传递实参
        //调用String参数的构造方法
    //    Student stu3 = new Student("刘德华");
        //***********构造方法的作用*********
        //之前我们可以通过set方法为成员属性赋值
        Student stu = new Student();
        stu.setName("刘德华");
        stu.setAge(20);
        stu.setSex('男');
        //使用带参的构造方法
        Student stu2 = new Student("张学友",20,'男');
    }
}

4 成员方法的分类及使用-一个标准的学生类

成员方法的分类：

         成员方法：定义在类体中，跟我们之前讲过的"方法"是一样的。可以带参数，可以具有返回值；

         成员方法的特点：必须要通过类的对象调用。必须先期实例化此类对象，因为只有实例化对象后，方法的空间才会被分配。

                            Student stu = new Student();

                            stu.show();

 

                            //不能直接调用show()

                            show();//错误。show()在Student类的内部，不能这样直接调用；

 

                            //不能通过类名调用:

                            Student.show();//错误：不能用"类名"调用；

         分类：

                   1.无返回值，无形参；

                   2.有返回值，无形参；

                   3.无返回值，有形参；

　　　　　　  4.有返回值，有形参；

class Student{
    //私有的成员属性
    private String name;
    private int age;
    private char sex;
    //*********构造方法*********
    //无参的
    Student(){
    }
    Student(String name,int age,char sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
//一些get和set方法
    void setName(String name){
        this.name = name;
    }
    //有返回值，无形参
    String getName(){
        return this.name;
    }
    //无返回值，有形参
    void setAge(int age){
        this.age = age;
    }
    int getAge(){
        return this.age;
    }
    void setSex(char sex){
        this.sex = sex;
    }
    char getSex(){
        return this.sex;
    }
    //无返回值，无形参
    void show(){
        System.out.println("大家好，我叫：" + this.name + ",性别：" + this.sex + ",今年：" + age + " 岁！");
    }
    //有返回值，有形参：
    String toString(int n){
        System.out.println("n = " + n);
        return this.name;
    }
}
class Demo {
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.show();//OK的；

        show();//编译错误
        Student.show();//编译错误
    }
}

5 static关键字

static关键字：

              1.static:静态的——全局的——整个应用程序范围内。

              2.有些成员变量具有固定的值，一般不会更改。

                            如果它作为"普通成员变量"：意味着，每次实例化这个对象时，都会在堆中分配空间。所以，如果对象

                                                      多了后，就会造成"空间浪费"；

              3.这时，我们可以将这种变量定义为:static

class Student
{
    static String schoolName = "传智播客--北京校区";
    String name;
    int age;

    Student(String name,int age){
        this.name = name;
        this.age = age;
    }
}
class Demo 
{
    public static void main(String[] args) 
    {
        Student stu = new Student("刘德华",20);
        System.out.println("第一个学员打印：" + stu.schoolName);

        stu.schoolName = "传智播客";//此值是共享的，只有一个存储空间。

        Student stu2 = new Student("张学友",22);
        System.out.println("第二个学员打印：" + stu2.schoolName);
    }
}

6  static关键字的特点

静态属性的应用：

              1.我们以后做项目时，总会有一些成员属性的值，在整个应用程序范围内是唯一的，

                而且被整个应用程序共享。

                例如：schoolName = "传智播客--北京校区";

              2.我们可以将这种字段全部定义在某个类中，并声明为static的。

class Const
{
    static String schoolName = "传智播客--北京校区";
    //我们的整个应用程序需要经常的计算圆的面积，需要使用统一的π值
    static double pi = 3.14159;
class Student{
    String schoolName  = Const.schoolName;
    //例如此方法要计算圆的面积
    void cal(){
    Const.pi * 半径 的平方
    }
}
class Teacher{
    String schoolName = Const.schoolName;
}
class Demo {
    public static void main(String[] args) {
        System.out.println("Hello World!");

7 静态的成员方法以及特点

静态关键字的特点：

              1.随着类的加载而加载；

              2.优先于"对象"而存在；在没有任何此类的对象的情况下，就已经存在了；

              3.被类的所有对象共享。也可以被其它类访问；

              4.可以通过"类名"调用。也可以通过"对象名"调用;

class Const{
    static String schoolName = "传智播客--北京校区";
    static double PI = 3.14159;
}
class Demo {
    public static void main(String[] args) {
//    Const con = new Const();//第一new这个类的对象，也会先将静态成员分配空间

System.out.println(Const.schoolName);//第一次使用Const类时，会自动加载内部所有的"静态成员"，并分配空间
System.out.println(Const.schoolName);//直接在内存中取System.out.println(Const.schoolName);//直接在内存中取
    Const con = new Const();
    System.out.println("con打印：" + con.schoolName);
    }

静态的成员方法(类方法)：

         1.一个成员方法也可以被修饰为static(静态的)

         2.一般一些"功能性"的方法：例如我们上午写的MyMath类中的加减乘除的一些方法

           为了方便用户使用，我们可以将这些方法定位为：static。

         3.用户使用时，可以不用实例化此类的实例，直接使用类名就可以调用了。

         静态方法的应用：

         1.我们以后做项目时，都会有一些"工具性"的方法：

                   例如：加、减、乘、除的方法；

                         对数组操作的一些方法：打印数组的内容，找数组中的最大值、最小值；

         2.我们可以将这些"工具性"的方法定义在某个类

使用户可以通过"类名"就可以直接调用了，不需要实例化此类的对象，方便了用户使用；

class MyMath{

         //此方法就可以不通过对象调用。可以通过类名直接调用。

         static int add(int a ,int b){

                   return a + b;

         }

}

class Demo {

         public static void main(String[] args)        {

//想使用add方法，必须先实例化一个MyMath对象；

         //       MyMath m = new MyMath();

         //       System.out.println(m.add(10,20));

                   //通过类名直接调用静态方法

System.out.println(MyMath.add(100,20));

8  static的注意事项

static关键字的小结和注意事项：

              1.static可以修饰：

                            1).成员变量：存在静态存储区。被所有对象共享；

                            2).成员方法：存在静态存储区。被所有对象共享；

              2.static关键字的特点：

                            1.随着类的加载而加载；

                            2.优先于对象而存在；

                            3.被所有类的对象共享；

                            4.可以通过"类名"调用，也可以通过"对象名"调用；

              static关键字的注意事项：

              1.在static的方法中，不能使用this关键字；(因为此时还没有对象空间产生)

              2.静态方法，只能访问静态成员(静态成员变量和静态成员方法)

                                                                                    普通的成员方法：

                                                                                    普通的成员变量

                                                                                    普通的成员方法

                                                                                    静态的成员变量

                                                                                    静态的成员方法

                                                        静态的成员方法：

                                                                                    静态的成员变量

                                                                                    静态的成员方法

class Student
{
    static String schoolName = "传智播客--北京校区";
    
}
class StudentTools
{
    void show(){
        Student stu = new Student();
    }
}
class  Demo 
{
    public static void main(String[] args) 
    {
        int a = 10;
    }
}

9  静态变量和成员变量的区别

静态变量和成员变量的区别：

              1.所属不同

                            1).静态变量：属于某个类，又叫"类变量"。

                            2).成员变量：属于"对象"，每个对象都有独立的成员变量的空间。也叫"实例变量"；

              2.内存中位置不同：

                            1).静态变量：在方法区的"静态存储区"中；

                            2).成员变量：在"堆"中；

              3.在内存中出现时间不同：

                            1).静态变量：第一次使用这个类时，可能还不会产生对象。此时就会为静态变量分配空间；

                            2).成员变量：在实例化类对象时，才会分配空间；

              4.调用不同：

                            1).静态变量：可以通过"类名"访问。也可以通过"对象"访问；

                            2).成员变量：必须要通过"对象"访问；

class Student{
    static String schoolName = "传智播客--北京校区";
    String name = "刘德华";
}
class Demo{
    public static void main(String[] args) 
    {
        System.out.println(Student.schoolName);//可以通过类名访问
        //访问成员变量：name
        Student stu = new Student();
        System.out.println(stu.name);//必须通过对象名访问
        System.out.println(stu.schoolName);//也可通过对象名访问。
    }
}

10 main方法的格式详细解释

public static void main(String[] args)

public :表示"公有的"，任何类都可以访问的；

         static :表示"静态的"，在不存在Demo的对象的情况下就可以直接访问；

         void   :返回值类型为"空"。

         main   :方法名，不是关键字。

         形参：String[] args:字符串数组。用于执行这个main方法时，传入参数；

11 说明书的制作过程

此类用于封装一些对数组进行操作的一些方法

              要对此类制作帮助文档：

 

              1.类要被声明为public；

              2.在源文件中添加"文档注释"；/**开头 * /结束。只有"文档注释"中的内容才会被编译到帮助文档中。

              3.对"类"和"方法"，以及方法的参数和返回值进行详细说明；

              4.在"命令提示符"下使用javadoc命令，生成帮助文档：

                                          javadoc -d 目录名  -author -version ArrayTools.java

 

                                          -d:使用目录；

                                          目录名：会将生成的帮助文档存入到这个目录下

                                          -author:识别@author标记；

                                          -version:识别@version标记：

 

*/
/**
    一个对数组操作的类。包含了一些静态的方法。
    @author 作者名
    @version 1.0
*/
 public class ArrayTools 
{
    //由于是一个工具类，内部包含都是静态方法。所以也不需要构造了。
private ArrayTools(){
    }
    //查找数组的最大值
    //参数：
    //返回值：
    /**
        获取数组的最大值。
        @param array 要查找的数组
        @return max 数组中的最大值
    */
public static int getMax(int[] array){
        int max = array[0];
        for(int i = 0;i < array.length ;i++){
            max = array[i] > max ? array[i] : max;
        }
        return max;
    }
    //查找数组的最小值
    /**
        获取数组的最小值
        @param array 要查找的数组
        @return min 数组中的最小值
    */
    public static int getMin(int[] array){
        int min = array[0];
        for(int i = 0;i < array.length ;i++){
            min = array[i] < min ? array[i] : min;
        }
        return min;
    }
}