乐趣区

关于java:零基础学Java第五节面向对象一

jiezi

本篇文章是《零根底学 Java》专栏的第五篇文章，文章采纳通俗易懂的文字、图示及代码实战，从零根底开始带大家走上高薪之路！

类与对象

在哲学体系中，能够分为主体（subject）和客体（object），在面向对象的程序设计语言中，所有的要面对的事物都能够形象为对象（object）。在面向对象的编程过程中，咱们就是应用各种各样的对象互相协同动作来实现咱们的程序性能。

在面向对象的语言中，所有应用中的对象都具备某种类型，这些类型之间也有档次关系，如同生物学中的门、纲、目、科、属、种一样，这种档次关系，咱们能够用继承这个机制来实现。

Java 语言为面向对象的语言，所有的对象都能够具备某些属性，以及具备某种行为性能。在 Java 语言中对象的属性用成员变量（域）形容，行为用办法形容。

类和对象之间的区别和分割就是，类是形象的，它具备一类对象所有的属性和行为，相当于模板，对象是具体的，通过创立相应类的对象来实现相应的性能。咱们在作面向对象的编程的时候，就是形象出类的属性和行为，再创立具体的对象来实现性能。

Date 类

定义

在 JDK 中，有一个用于形容日期的类：java.util.Date，它示意特定的霎时，准确到毫秒。在这里咱们本人定义一个简略的 Date 类，用来示意具备年、月、日的日期。咱们先来看看如下定义怎么样？

public class Date{
    public int year;
    public int month;
    public int day;
}

在这段程序定义中，类定义为 public，同时 year、month、day 也定义为 public，它们是什么含意呢？

咱们后面提到包这个概念，咱们说，在同一个包中的类在性能上是相干的，然而在包内的这些类并非全副都能够被其余包中的类调用的，怎么辨别呢？那些能够被包外应用的类，咱们在定义的时候，在类名前加上 public，而不能被包外应用的类，在定义的时候，不要加 public。

year、month、day 这些在类体中所定义的变量，咱们称之为成员变量（域 field），那么成员变量后面的 public 的作用是阐明这些变量是公开的，能够被以 对象. 变量 这种模式调用，这称为成员变量的拜访权限。比方本例：咱们定义一个Date 类型的变量 d1，那么咱们能够通过d1.year 来应用 d1 这个对象中的year。在定义成员变量的时候，除了能够定义为public，还能够有protected、缺省（无权限修饰词）、private，它们的限度越来越严格，咱们总结一下：

  • public：被 public 润饰的成员是齐全公开的，能够被以任何非法的拜访模式而拜访
  • protected：被 protected 润饰的成员能够在定义它们的类中拜访，也可被同一包中的其余类及其子类（该子类能够同其不在同一个包中）拜访，但不能被其余包中的非子类拜访
  • 缺省：指不应用权限修饰符。该类成员能够在定义它们的类中被拜访，也可被其同一包中的其余类拜访，但不能被其余包中的类拜访，其子类如果与其不在同一个包，也是不能拜访的。
  • private：只能在定义它们的类中拜访，仅此而已。

在类中，咱们岂但能够定义成员变量，还能够定义成员办法，成员办法后面也能够有这四种权限管制，含意是一样的。然而大家千万不要认为在独立类的后面也能够有 private、protected 这两个修饰词，在类前只能有 public 或者没有，含意后面已述。

对于 public 类和源程序文件的关系，咱们在以前学习过，这里再从新提一下：

每个源代码文件中至多定义一个类，若有多个类，最多 只有一个类定义为 public，若有 public 类，则该源代码文件的前缀名字要同该类的类名完全一致，若没有 public 类，则源代码文件的前缀名可不与文件内的任何类统一。

测试

下面的 Date 类曾经定义好了，咱们怎么测试这个类呢？咱们在这个类中定义 main 办法了吗？没有 main 办法的类，能够以 java 类名 这种形式在控制台中执行吗？显然不行，那怎么办呢？有两种计划，一种是咱们给它定义一个main 办法；另一种计划，再定义一个类，专门测试这个 Date 类。咱们顺次来看看。

增加 main 办法

咱们在 Date 的定义中退出 main 办法，代码如下：

public class Date{
    public int year;
    public int month;
    public int day;

    public static void main(String[] args){
        year = 2016;
        month = 9;
        day = 5;
        System.out.println("year:" + year + "month:" + month + "day:" + day);
    }
}

编译 …，怎么？又错了？
别慌，看看出错提醒，都是 无奈从动态上下文中援用非动态 变量 这样的提醒，这是什么意思？咱们看看 main 办法后面是不是有个修饰词 static，咱们后面提到凡 static 润饰的成员变量或者办法，都能够用 类名. 成员 这种模式来拜访。如果 Date 类在控制台中以 java Date 这种命令模式来执行，我想请问，零碎是创立了一个 Date 对象了，而后再执行这个对象中的 main 办法这种形式来执行的 Date 类吗？错，零碎是间接找到 Date.class 这个类文件，把这个类调入内存，而后间接执行了 main，这时在内存中并没有 Date 对象存在，这就是为什么 main 要定义为 static，因为 main 是通过类来执行的，不是通过对象来执行的。

那下面的解释又同这个编译谬误提醒什么关系？咱们看看 year、month、day 后面有没有 static 这个修饰词？没有，这阐明这些成员变量不能通过类名间接拜访，必须通过创立类的对象，再通过对象来拜访。而 main 在执行的时候，内存中并没有对象存在，那天然那些没有 static 润饰的成员就不能被拜访，因为它们不存在，是不是这个逻辑？想明确了吗？还没有？再想想！

咱们得出个能记住的论断，在 static 润饰的办法中，只能应用本类中那些 static 润饰的成员（包含成员变量、办法等），如果应用本类中非 static 的成员，也必须创立本类的对象，通过对象应用。好吧，不明确情理，就先把这个论断记着。

咱们依据下面的论断，把测试代码再改改：

public class Date2{
    public int year;
    public int month;
    public int day;

    public static void main(String[] args){Date2 d1 = new Date2();
        d1.year = 2016;
        d1.month = 9;
        d1.day = 5;
        System.out.println("year:" + d1.year + "month:" + d1.month + "day:" + d1.day);
    }
}

编译 …，OK，运行，通过，

那如果非静态方法中应用动态成员，可不可以呢？咱们说能够，简略讲，这是因为 类先于 对象 存在，动态成员依赖于 类，非动态成员依赖于 对象。

下面的程序中，咱们给这几个成员变量别离给了值，如果不给值间接输入呢？咱们试试：

public class Date3{
    public int year;
    public int month;
    public int day;

    public static void main(String[] args){Date3 d1 = new Date3();
        System.out.println("year:" + d1.year + "month:" + d1.month + "day:" + d1.day);
    }
}

编译，运行，后果：，都是 0。这里有个论断：成员变量如果没有显式初始化，其初始值为 0 值，或者相当于 0 值的值，比方援用变量，未显式初始化，其值为 null，逻辑变量的未显式初始化的值为 false。这里要留神，咱们说的是成员变量，如果是局部变量，没有显式初始化就用，编译是通不过的。比方下面的代码，改为：

public class Date3{
    public int year;
    public int month;
    public int day;

    public static void main(String[] args){
        Date3 d1;// 这里 d1 为局部变量，没有初始化
        System.out.println("year:" + d1.year + "month:" + d1.month + "day:" + d1.day);
    }
}

编译： 从编译提醒，咱们晓得 d1 未初始化就用，这是不对的。

创立一个测试类

代码如下：

// 本类放在 Date.java 文件中
public class Date{
    public int year;
    public int month;
    public int day;
}

// 本类放在 TestDate.java 文件中
public class TestDate{public static void main(String[] args){Date d1 = new Date();
        d1.year = 2016;
        d1.month = 9;
        d1.day = 5;
        System.out.println("year:" + d1.year + "month:" + d1.month + "day:" + d1.day);
    }
}

这两个类都是 public 类，所以，这两个类应该写在两个不同的源代码文件中，文件名别离为：Date.java 与 TestDate.java 中。如果大家想将这两个类写在一个源代码文件中，因为 Date 类在测试实现当前是会被公开应用的，所以咱们应该把 Date 定义为 public，那么源代码文件的名字就是Date.java，而 TestDate 这个类是用于测试 Date 类的，所以它后面的 public 就应该去掉。代码如下：

// 这些代码放在 Date.java 文件中
class TestDate{public static void main(String[] args){Date d1 = new Date();
        d1.year = 2016;
        d1.month = 9;
        d1.day = 5;
        System.out.println("year:" + d1.year + "month:" + d1.month + "day:" + d1.day);
    }
}

public class Date{
    public int year;
    public int month;
    public int day;
}

这两个类的定义程序无关紧要。编译后，咱们在命令行上执行：java TestDate即可。

思考

封装

在这个示例中，有个问题：咱们在创立 Date 对象 d1 当前，就间接应用 d1. 这种模式给 year、month、day 赋值了，如果咱们给它们的值不是一个非法的值怎么办？比方 month 的值不在 1~12 之间，等等问题。在如上的 Date 定义中，咱们没有方法管制其余代码对这些 public 润饰的变量随便设置值。

咱们能够把这些成员变量用 private 修饰词爱护起来。由 private 润饰的成员，只能在类或对象外部自我拜访，在内部不能拜访，把下面的 Date 代码改为：

public class Date{
    private int year;
    private int month;
    private int day;
}

这样咱们就不能够通过 d1.year 来拜访 d1 对象中 year 了。慢着，不能拜访 year，那这个变量还有什么用？是的，如果没有其它伎俩，下面的这个类就是无用的一个类，咱们基本没有方法在其中存放数据。

怎么办？咱们通过为每个 private 的成员变量减少一对 public 的办法来对这些变量进行设置值和获取值。这些办法的命名形式为：setXxx 和 getXxx，setter 办法为变量赋值，getter 取变量的值，布尔类型的变量的取值用：isXxx 命名，Xxx 为变量的名字，上例改为：

public class Date{
    private int year;
    private int month;
    private int day;

    public void setYear(int year){
        // 实践上 year 是没有公元 0 年的，咱们对传入的值为 0 的实参解决为 1
        //year 的正值示意 AD，负值示意 BC
        if(year == 0){
            // 这里有两个 year，一个是成员变量，一个是实参，这是容许的
            // 为了辨别它们，在成员变量 year 后面加上 this.
            // 实参 year 不做解决
            // 如果没有变量和成员变量同名，this 是能够不写的
            this.year = 1;
        } else {this.year = year;}
    }

    // 因为要取的是 year 的值，所以 getter 办法的返回值同所取变量的类型统一
    public int getYear(){return year;}

    public void setMonth(int month){if((month > 0) && (month < 13)){this.month = month;} else{this.month = 1;}
    }

    public int getMonth(){return month;}

    public void setDay(int day){
        // 这个办法有些简单，因为咱们须要依据 year、month 的值来判断实参的值是否合规
        switch(month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:if (day < 32 && day > 0) {// 在 1~31 范畴内
                        this.day = day;
                    }else{this.day = 1;// 超出日期失常范畴，咱们设为 1}
                    break;
            case 4:
            case 6:
            case 9:
            case 11:if (day < 31 && day > 0) {// 在 1~30 范畴内
                        this.day = day;
                    }else{this.day = 1;// 超出日期失常范畴，咱们设为 1}
                    break;
            case 2:if (isLeapYear()) {if (day < 30 && day > 0) {// 在 1~29 范畴内
                            this.day = day;
                        }else{this.day = 1;// 超出日期失常范畴，咱们设为 1}
                    } else {if (day < 29 && day > 0) {// 在 1~28 范畴内
                            this.day = day;
                        }else{this.day = 1;// 超出日期失常范畴，咱们设为 1}
                    }
                    break;
            default:this.day = 1;// 如果 month 的值不在上述情况下，day 设置为 1        
                    break;        
        }
    }

    // 这个办法判断年份是否为平年，是平年返回 true，否则返回 false
    // 该办法只在本类外部应用，所以定义为 private
    private boolean isLeapYear(){
        // 可被 400 整除或者被 4 整除但不能被 100 整除的年份为平年，其它年份为平年
        if((year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0))){return true;}

        return false;// 能执行这里，阐明是平年
    }
}

通过下面的革新，尽管代码长了很多，然而平安了很多。咱们对 year、month、day 的值不再是直接存取，而是通过相应变量的 getter 和 setter 办法来存取，这些办法在进行存取的时候，会判断设置的值是否合规。

下面的代码其实是能够优化的，比方 setDay 能够优化如下：

    public void setDay(int day){
        // 这个办法有些简单，因为咱们须要依据 year、month 的值来判断实参的值是否合规
        this.day = 1;// 这里先把 day 设置为 1，上面的超范围的状况就不必再写代码了
        switch(month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:if (day < 32 && day > 0) {// 在 1~31 范畴内
                        this.day = day;
                    }
                    break;
            case 4:
            case 6:
            case 9:
            case 11:if (day < 31 && day > 0) {// 在 1~30 范畴内
                        this.day = day;
                    }
                    break;
            case 2:if (isLeapYear()) {if (day < 30 && day > 0) {// 在 1~29 范畴内
                            this.day = day;
                        }
                    } else {if (day < 29 && day > 0) {// 在 1~28 范畴内
                            this.day = day;
                        }
                    }
                    break;
        }
    }

咱们通过下面的示例，看到了面向对象的一个概念：封装。咱们将数据用 private 暗藏起来，通过 public 存取方法对数据进行了封装，使得数据更加平安与牢靠。

成员变量的初始化

非动态成员变量的初始化

在下面的例子中，如果咱们新建一个 Date 对象当前，如果不初始化，咱们能够晓得，间接取其中的 year、month、day 的值的时候，它们的值都是 0，这显然是不合理的。要解决这个问题，咱们须要在创立 Date 对象的时候，让零碎主动初始化一个适合的值，要达到此目标，咱们能够采纳三种形式：

  • 在定义成员变量的时候初始化值，如下面的代码，咱们批改一下如下：

    public class Date{
    private int year = 1;
    private int month = 1;
    private int day = 1;

    ...

}

    下面的代码，使得新建 Date 对象的初始值均为 1。

  • 第二种形式为应用构造方法

    构造方法是类中一种特地的办法，它的办法名和类名统一，该办法没有返回值，甚至连 void 都没有，而且构造方法不能被当作一般办法一样被调用，每当生成某个类的对象的时候，构造方法才被调用。构造方法的作用就是在创建对象的时候执行对对象的初始化工作。咱们应用构造方法对成员变量来进行初始化，代码如下：

    public class Date{
    private int year;
    private int month;
    private int day;

    public Date(){
        year = 1;
        month = 1;
        day = 1;
    }

    ...

}

    下面的代码使得咱们在新建 Date 对象时，能够初始化其内的值。下面的构造方法没有参数，这种构造方法，咱们称之为 默认构造方法。那是不是用构造方法只能初始化为这种固定的值呢？能不能在创建对象的时候再指定初始化值呢？答案是能够的，就是应用有参数的构造方法。代码如下：

    public class Date{
    private int year;
    private int month;
    private int day;

    public Date(int year, int month, int day){
        // 上面的代码应用 setter 办法进行初始化是因为，setter 办法提供了参数查看，// 如果不必 setter 办法，咱们就须要从新写对参数的查看代码
        setYear(year);
        setMonth(month);
        setDay(day);
    }

    ...

}

    下面的代码使得咱们能够在创立新的 Date 对象的时候指定初始化值，比方：Date d = new Date(2016,9,5);。然而下面的代码没有定义无参构造方法，咱们再用无参构造方法来创立 Date 对象就不行了，如：Date d = new Date();，编译时会呈现如图的谬误：
    这是为什么呢？这是因为，如果定义类时没有定义构造方法，则编译器会主动创立一个无参的空的 public 构造方法，作为该类的构造方法。然而，只有你定义了构造方法，不论是有参还是无参，编译器就不再主动生成了，就会呈现下面的谬误提醒。

    另外，在构造方法中产生的异样会被 jvm 疏忽，即便是在构造方法中应用 try 也杯水车薪。

    public class Test {public Test() {
        try {System.out.println("trying to throw an exception");
            double x = 1.0/0.0;// 此句会产生除 0 异样
        } catch(Exception e) {System.out.println("Exception captured");
           } finally {System.out.println("inside finally");
        }
    }

       public static void main(String args[]) {Test test = new Test();
    }
}

    上述代码在执行当前的后果如图： 从图大家能够看到产生的异样并未被 catch。

  • 第三种形式是应用实例语句块。那么什么是实例语句块呢？实例语句块是由一对大括号括起来的能够被执行的语句序列，这个语句块在类的外部，但不在任何办法的外部，如下代码：

    public class Date{
    private int year;
    private int month;
    private int day;
    
    // 上面的大括号为实例语句块
    {
        year = 1;
        month = 1;
        day = 1;
    }

    ...

}

    下面的实例语句块会在构造方法执行前被执行。如果呈现多个实例语句块，按程序执行。

  • 如果这三种形式同时采纳呢？代码如下：

    public class Date{
    private int year = 1;
    private int month = 1;
    private int day = 1;

    {
        year = 2;
        month = 2;
        day = 2;
    }
    public Date(){
        year = 3;
        month = 3;
        day = 3;
    }

    ...

}

    下面的 Date 类，如果要新建对象，其初始值是 1、2，还是 3 呢？在创建对象的时候，会在堆中为对象调配存储空间再将所调配空间的所有内容都设为默认初始值 0，接着将成员变量定义时的值对成员变量进行初始化，再执行实例语句块，最初执行构造方法。因而，上例的初始最终值为 3。

动态成员变量的初始化

  • 咱们后面所波及到的是对非动态成员变量的初始化，咱们晓得有一类成员变量是用 static 润饰的，这类成员变量是不依赖对象的，那么这类变量如何初始化呢？
    首先咱们要明确，动态成员变量的存储空间不同任何该类的对象相关联，它们的存储空间是独立的。由此，咱们能够得出两个论断，首先动态成员变量的值只能被初始化一次，其次，动态成员变量的值不能在构造方法中初始化（因为构造方法是在创建对象的时候调用的）。
    那么怎么对动态成员变量进行初始化呢？有两种形式：

    • 象初始化非动态成员变量一样，间接给动态成员变量赋初始值，如：

      public class Test{
    public static int first = 1;
    public static int second = 2; 
}

    • 第二种，应用动态语句块，如下：

      public class Test{
    public static int first;
    public static int second;
    // 上面的语句就是动态语句块，这种语句块不能放在办法体中
    static{
        first = 1;
        second = 2;
    } 
}

      在类中，能够呈现多个动态语句块，多个动态语句块程序执行。

    • 动态成员变量的初始化产生在该成员变量第一次被应用的时候，之后该成员变量不会再反复初始化。而且类中的动态成员变量的初始化产生在非动态成员变量的初始化之前，这样，上面的代码就不适合了：

      public class Test{
    public int first = 1;
    public static int second = first;
}

类定义中的成员

Java 的类中能够蕴含两种成员：实例成员和类成员。

实例成员

  • 实例成员（包含实例成员变量及实例办法）属于对象，通过援用拜访：

    • 援用变量. 实例成员名;

    • 定义类时，如果成员未被 static 润饰，则所定义的成员为实例成员，如：

      int i=10;
void f(){…}

  • 实例成员的存储调配

    • 通常，类只是形容，通过应用 new，对对象进行存储空间调配。未被 static 所润饰的成员是对象的一部分，因而，这种实例成员的存储调配随同对象的调配而调配。

    • 例如：

      class T{
int i;
void f(){}
}。。。T t1,t2;
t1=new T();
t2=new T();

      则此时，i 有两个正本，一个在 t1 中，一个 t2 中，通过 t1.i 及 t2.i 应用

    类成员

  • 类成员（包含类成员变量及类办法）属于类，通过类名拜访，也可通过援用拜访：

    • 类名. 类成员名;

    • 定义类时，如果成员被 static 润饰，则所定义的成员为类成员，如：

      static int count=0;
public static void main(String args[]){…}

  • 类成员的存储调配

    • static 用于成员变量前，则不论有多少对象，该成员变量只保留一份公共存储，称为类变量（动态变量）；
    • 如果在定义方法时，应用 static 进行润饰，称为类办法（静态方法），则在调用该 static 办法，则该办法不依赖具体对象，既是你能够调用某个办法，而不必创建对象。

    • 对于类成员的应用，即能够应用类名应用，也能够通过援用应用，如：

      class T{
static int i=47;
static void f(){i++;}
}。。。T t1,t2;
t1=new T();
t2=new T();

      则此时，i 只有一份，既通过 t1.i 及 t2.i 应用，也可通过 T.i 援用，其值均为 47。在执行 T.i++; 后 t1.i 及 t2.i 的值均为 48；对 f 的调用既能够以如 t1.f(); 也能够 T.f(); 形式应用。依据 java 编程标准，咱们倡议对于 static 成员，只采纳类名援用的形式。

类成员、实例成员总结
  • 当你应用 static 就意味着, 这个成员变量或办法不依赖于任何该类的对象，所以无需创建对象，就可应用该 static 数据或办法。
  • 对于 non-static 数据和办法则必须创建对象，而后应用该对象操作 non-static 数据和办法。
  • 由此，因为 static 办法不须要创建对象，所以 static 办法不能直接存取非 static 成员。

  • 而 non-static 办法则能够间接调用 static 成员

    public class Test{
  static int i=0;
  int j=10;

  static void f(){i++;}
  void s(){f(); j++;}

  public static void main(String[] args){Test t=new Test();
      t.s();
      System.out.println(i);
  }
}
  • static 的一个重要利用就是无需创建对象而调用办法。比方 main()
  • 在定义一个类时，共性的定义为 non-static，共性的定义为 static

this

在 Java 中咱们常常看到对 this 这个关键字地应用。它的应用有两种场合：

  • this 作为一个援用用来援用本身，每个对象都有一个 this。在类的成员办法中，this 用于示意对本对象内的办法或者变量的应用。如果在不会引起歧义的状况下，this 是能够省略的。比方下面的一系列 setter 办法中，因为参数同成员变量同名，为了以示区别，成员变量前的 this 就不能省略了。

    this 不能用在静态方法中。因为静态方法的执行基本不须要 java 对象的存在，而是间接应用 类名. 办法 的形式拜访，而 this 代表的是以后对象，所以在静态方法中根本无法应用 this。

  • this 能够用在构造方法中，对本类中其它构造方法进行调用

    • 语法：this([实参]);
    • 作用：在一个构造方法中去调用另一个构造方法。
    • 目标：代码重用。
    • this(实参)：必须是构造方法中第一个被执行的语句，且只被调用一次。

    咱们读读上面的代码

    public class Flower {
    int petalCount = 0;
    String s = new String("null");

    Flower(int petals) {
        petalCount = petals;
        System.out.println("Constructor with int arg only, petalCount="+ petalCount);
    }

    Flower(String ss) {System.out.println("Constructor with String arg only, s=" + ss);
        s = ss;
    }

    Flower(String s, int petals) {this(petals); // 调用 Flower(petals)，但不能写作 Flower(petals)
        //! this(s); // Can't call two!
        this.s = s; // 这是 this 的另一种应用形式
        System.out.println("String & int args");
    }

    Flower() {this("hi", 47);
        System.out.println("default constructor (no args)");
    }

    void print() {//! this(11); // Not inside non-constructor!
        System.out.println("petalCount =" + petalCount + "s ="+ s);
    }

    public static void main(String[] args) {Flower x = new Flower();
        x.print();}
} ///:~

private 构造方法

在构造方法前也能够有 public 等修饰词用于限定构造方法的存取权限。个别状况下，如果类是 public，构造方法也是 public，这样通过 new 能力调用。所以，如果构造方法后面被 private 润饰，那会产生什么事件呢？咱们在类外就不能生成该类的对象了。大家能够本人测试一下。

那是不是 private 就不能用在构造方法后面了呢？当然能够，而且这是一种很有用的状况。在有些状况下，有些类在零碎中只能容许存在一个该类的实例（对象），这时，咱们就能够把该类的构造方法定义为 private 的。示例代码如下：

public class Handler {
    //handler 变量用来保留该类对象的援用
    private static Handler handler = null;
    private Handler() {/* set something here */}

    // 该类的对象只能通过 getHandler 办法从 handler 这个公有变量中获取
    public static getHandler(/* arglist */) {
        // 如果 handler 值非空，阐明曾经在零碎中存在该类的对象，间接取出，不再生成，这就保障了单例
        if (!handler)
             handler = new Handler();
       return handler;
    }

    public static void main(String args[]) {Handler.getHandler();
    }
}
退出移动版