类与对象

第五章： Objects and Classes 


一. OOP中的基本概念


    Java的编程语言是面向对象的，采用这种语言进行编程称为面向对象编程(Object-Oriented Programming, OOP)， 它允许
    设计者将面向对象设计实现为一个可运行的系统。Java的编程单位是类，对象最后要通过类进行实例化(即“创建”)。


    面向对象编程有三个特性：
      (先简单的了解一下这三个特点)
    . 封装 Encapsulation：以前我们讲过java是以类为基础的，所有的属性和方法都是封装在类中的，不像C++在类外还可以定义函数。
    . 继承 Inheritance：不容置疑，从父亲那里继承什么家产、金钱或者产业什么的，运用到我们java中又是怎么回事呢？它又继承哪些东东呢？
    . 多态 Polymorphism：表面看是多种状态的意思。(这里先不过多讨论，下面会详细讨论)


    接下来我们就要对这三个特性进行详细的分析，那么在java中我们一切是以类为基础，当然这三个特性跟类是分不开的，那我们认识下java中的类。


二. 抽象数据类型(类就是模板)


    在C++中，我们可以用struct 来表示一个类，不了解也不要紧。
    在java中，我们用class 这个关键字来表示一个类，类是一个抽象的数据类型，那怎么抽象法呢？
(思考一下我们之前讲过的java中的类是怎么来的)
三. 类和对象


    面向对象的开发方法把软件系统看成各种对象的集合，对象就是最小的子系统，一组相关的对象能够组合成更复杂的子系统。面向对象的开发方法将软件系统看成各种对象的集合，接近人的自然思维方式。


    对象是对问题领域中事件的抽象。对象具有以下特性：


    1) 万物皆为对象。问题领域中的实体和概念都可以抽象为对象。例如学生，成绩单、教师、课和教室。
    2) 每个对象都是惟一的。正如世界上不存在一模一样的数子(或者人)。
    3) 对象具有属性和行为。
       例如小张，性别女，年龄22，身高1.6m, 体重40kg, 能够学习，唱歌。小张的属性包括姓名、性别、年龄、身高和
       体重，行为包括学习、唱歌。
       例如一部手机，牌子是诺基亚、价格是2000元，银白色，能够拍照、打电话和收发短信等。这部手机的属性包括品
       牌类型type、价格price和颜色color，行为包括拍照takePhoto()，打电话call()，收发短信receiveMessage()和发短
       信sendMessage().
    4) 对象具有状态。状态是指某个瞬间对象的各个属性的取值。对象的某些行为会改变对象自身的状态，即属性的取值。
       例如小张本来体重为40kg，经为减肥后，体重减到45kg. 


       肥胖状态: 40kg
              |
              | 减肥行为
              |              
       肥胖状态: 45kg 
     
    5) 每个对象都是某个类的实例。小张和小王都属于学生类、中国和美国都属于国家类、中文和英文都属于语言类。
       类是具有相同属性和行为的对象的集合。


       同一个类的所有实例都有相同属性，但属性取值不一事实上相同，但是它们的状态不一定相同。例如小张和小王都属
       于学生类，都有姓名、性别、年龄、身高和体重这些属性，但是他们的属性取值不同。


       同一个类的所有实例都有相同行为，意味着它们具有一些相同的功能。


    类是一组具有相同属性和行为对象的模板。面向对象编程的主要任务就是定义对象模型中的各个类。   
  
    1) 类是一种类型：是引用类型；
    2) 类是元数据：  描述数据的数据，因为数据在面向对象领域里以对象的形式存在，所以类是对象共有属性和方法的抽象描述。


    Java程序是各种对象相互交互作用、而不是类。举例：


    1) 早上到公司上班，在电梯中碰到总经理我们会说，张总早或王总早，会不会说人早呀！
    2) 我们要看电视，是买台电视机，而不是买制作电视机的模具；


    在java中，类的申明和实现在同一时间，而且必须在一起，前面我们已经做过很多的例子。
    在C++中，类的申明和实现可以被分开，不知道也没有关系，这只是让我们了解下两者的区别。


四. 类中方法的定义


    接下来我们来看一下类中定义的方法的格式。
    修饰符 返回类型 方法名（参数列表）异常抛出类型{...}


    1) 必须有返回值，如果方法没有返回值，必须用void申明返回类型。
    2) 构造器没有返回类型，构造器加上了返回类型就变成了一个普通方法的声明了。
    3) 方法的修饰符可以同时有多个(多个修饰符之间没有先后顺序)


    注意:return_type:如果方法定义了返回类型,那么在方法体里面就必须出现return语句,而且返回的数据类型要和声明一致,如果没有返回类型的话(void),那么方法体里面可以写return,也可以不写return。当代码执行了return语句,那么代码就不往下执行了,直接退出这个方法并返回


    方法中定义的参数我们通常叫做形参，调用有参数的方法时，我们通常会
    传递一些实参给方法，那么在java中方法的参数是如何的传递呢？
（先思考形参和实参的区别）


    //temp是形参
public void add(int temp){
  .....
}


main{
//1是实参
add(1);
// temp = 1;




int a = 10;
//a是实参
add(a);
// temp = a;


}






五. 参数传递


    参数传递分为两种：
    1) 值传递:对于基本数据类型，参数通过值传递。(把实参的值复制一份再传给形参)
    2) 引用传递:对于引用类型，参数通过引用(对象的引用)传递。(把实参引用中地址值复制一份再传给形参)
    参考例子ParameterPassTest.java






六. this关键字


    在方法调用、参数传递过程中，极有可能出现参数名称与实例变量名同时的情况。在一个方法内，可以定义和成员变量同名的局部变量或参数，此时成员变量被屏蔽。


    参考例子:Student.java。
    
作用1：区别成员变量和局部变量
public class Student{
private String name;
public void setName(String name){
this.name = name;
System.out.print(name);
String name;
name = "tom";
}


}    


作用2：
public class Student{
private String name;


public void setName(String name){
this.name = name;
}
public void print(){
//表示调用当前类中的setName方法
this.setName("tom");
//setName("tom");


//在类中可以表示当前类的对象
System.out.println("this:"+this);
}

public static void main(String[] args){
Student s = new Student();
s.setName("tom");
System.out.println("s:"+s);
}
}






作用3: 在类的构造器中用this关键字可以调用类的其他的构造器
1.this只能出现在构造函数代码块中的第一句(前提是this这个时候代表的是调用其他构造器)
2.由this调用的构造器不会再创建新的对象
例如:
public class Car{
private String name;
private double price;


public Car(){
//无参构造器中调用了一个参数的构造器
this("tom");
}
public Car(String name){
//一个参数的构造器中调用了俩个参数的构造器
this(name,100000);
}
public Car(String name,double price){
this.name = name;
this.price = price;
}


}


-------------------------------------------------------------------------------------------------------------------


七. 数据隐藏
    
    这里说说的数据主要指的是类中的属性
    如何对属性进行隐藏呢？
    在前面封装的属性前面用private修饰，表示该属性不能被其它类访问和修改，它只能被本类访问和修改，范围限制在本类内。


    java中封装有两个方面：
    属性的封装
方法的封装


八. 封装
    1.对属性的封装
        首先属性可以被一下修饰符修饰:
public protected "default" private(这四种修饰符可以修饰成员变量,也可以修饰方法)
public String name;
protected String name;
private String name;
//这样就是default
        String name;


//这样写是错的
default String name;


      注:  四种修饰符的作用之后会讨论


      对属性的封装:在属性(实例变量)前加private, 然后通过统一的方法访问以及修改这些属性值；
      使用get/set方法来访问类中被private修饰的属性。


      这样做的目的就是隐藏数据信息，保证数据的安全.


    
    2.方法的封装:(指的是用方法来封装代码)
      站在使用的者的角度去考虑，用户只关心方法的使用,不管里面到底怎么实现的细节.
      从编程的角度去看的话:为了代码的重用.


    


九. 方法重载(overload)


    有时侯，类的同一种功能有多种实现方式，换句话说，有很多相同名称的方法，参数不同。这给用户对这种功能的调用使用提供了很大的灵活性。
    例如:Test类中要求有俩个方法:
public void print(int i){
System.out.println("i = "+i);
}
 
public void print(String s){
System.out.println("s = "+s);
}


    对于类的方法(包括从父类中继承的方法), 如果有两个方法的方法名相同，但参数不一致，那么可以说，一个方法是另一个方法的重载方法。这种现象叫重载。


    重载必须满足以下条件：
    1) 方法名称相同。
    2) 参数列表不同(参数类型、个数和顺序)。
    注意: 返回类型可以不相同。


    在一个类中不允许定义两个方法名相同，并且参数签名也完全相同的方法。因为假如存在这样的两个方法，Java虚拟机在运行时就无法决定到底执行哪个方法。参数签名是指参数的类型、个数和顺序。




十. 创建和初始化对象


    按照前面讲述的定义类的形式、定义方法的形式，构建好类了之后，程序要真实的运行，还是得通过对象的交互来完成。创建好了类，只是创建了构建对象的模板。接下来，我们可以通过new操作符，快速地构建出对象。使用new有以下作用有以下几步：


    1.为对象分配内存空间，将对象的实例变量自动初始化默认值；
    2.如实例变量显示初始化，将初始化值赋给实例变量(把默认值覆盖掉)；
    3.调用构造方法；
    4.返回对象的地址值；
    (注意:之后我们会把这个步骤再细分)


十一. 构造方法
(构造器/构造函数/构造方法)
    1. 定义：


    . 构造方法的名字和类的名字相同
    . 没有返回类型，有返回类型的构造器就变成了普通方法。


    2. 调用时刻：


    在创建对象的时候调用；
    注意：是先创建对象，然后初始化对象中的属性值,最后在调用构造器


    3. 作用：
    可以让我们在创建对象的时候做一些对象中数据的初始化工作.(因为在new的后面就是写的构造器)
new Student();
new Student("tom",age);


    4. 构造方法的调用：


    构造方法只能通过以下方式被调用：
    . 当前类的其他构造方法通过this语句调用它；
    . 当前类的子类的构造方法通过super语句调用它；
    . 在程序中通过new语句调用它；


十二. 构造方法重载


    当通过new语句创建一个对象时，在不同的条件下，对象可能会有不同的初始化行为。例如对于公司新来的一个雇员，在一开始的时侯，有可能他的姓名和年龄是未知的，也有可能仅仅他的姓名是已知的，也有可能姓名和年龄都是已知的。如果姓名是未知的，就暂且把姓名设为“无名氏”，如果年龄是未知的，就暂且把年龄设为-1. 


    可通过重载构造方法来表达对象的多种初始化行为。在一个类的多个构造方法中，可能会出现一些重复操作。为了 提高代码的可重用性，Java语言允许在一个构造方法中，用this语句来调用另一个构造方法。


  使用this语句来调用其他构造方法时，必须遵守以下语法规则:


  1.假如在一个构造方法中使用了this语句，那么它必须作为构造方法的第一条要执行的语句(不考虑注释语句)。
      
      public Employee() {
          String name="无名氏";
          this(name);      //编译错误，this语句必须作为第一条语句
      }
      public Employee(String name) {
          String name=name;
      }


  2.只能在一个构造方法中用this语句来调用类的其他构造方法，而不能在实例方法中用this语句来调用类的其他构造方法；


  3.只能用this语句来调用其他构造方法，而不能通过方法名来直接调用构造方法。


      public Employee() {
          Employee(name);      //编译错误，要使用this关键字来调用
          String name="无名氏";
      }
      public Employee(String name) {
          String name=name;
      }


         


十三. 默认的构造方法


    构造方法可分为两种：
    1) 隐含的默认构造方法(无参构造器)；
    2) 程序显示定义的构造方法；


    在Java语言中，每个类至少有一个构造方法。为了保证这一点，如果用户定义类中没有提供任何构造方法，那么在运行的时候JVM将自动提供一个隐含的默认构造方法。该构造方法没有参数，用public修饰，而且方法体为空，格式如下：


    public ClassName(){}      //隐含的默认构造方法


    在程序中也可以显示地定义默认构造方法。


    如果类中显式定义了一个或多个构造方法，那么Java语言便不再分配隐含的默认构造方法。举例：


    public class Sample{
public Sample(int a) {
System.out.println("My Constructor");
  }
    }


    创建Sample类对象的语句:


    Sample s1 = new Sample();        //编译出错
    Sample s2 = new Sample(1);       //合法的






十四. 子类
    1. 通过生活中的例子推出Java中继承;


    什么是继承呢？生活中不乏这样的例子，张老头有个儿子张小头，张老头健在的时侯，张小头继承了张老头的坏脾气，国字脸，八字脚。张小头只有亲生爸爸张老头，张老头却有包括张小头在内的多个子女。


    Java中类与类之间也有生活中类似的继承关系。在Java类继承关系中，对应于父亲的类叫父类，对应于儿子的类叫子类。父子类间的继承关系也叫“is a”关系。这种关系通过类声明上的extends关键字体现。


    一个子类只有一个父类，一个父类可有多个子类。


    2. 为什么要继承？ 


    . 站在巨人的肩膀上；通过继承，我们可以快速构建出一个带有丰富功能的新类；有了张老头，张小头年纪轻轻就可以买上上百万的新房；
    . 不修改源代码，修改既有类的行为；通过继承，在子类中构建父类中一样的方法，可以改变父类方法的行为。张老头没有考上大学，通过张小头圆了其上大学的梦。


    3. Object类简略介绍


    所有的Java类都直接或间接地继承了java.lang.Object类。Object类是所有Java类的祖先，在这个类中定义了所有的Java对象都具有相同行为。


十五.  继承


    子类继承了父类的属性和方法：


    1) 父子类同包，子类继承父类中public、protected和默认访问级别的成员变量和成员方法；
    2) 父子类不同包，子类继承父类中public、protected的成员变量和成员方法；


    那么继承有哪些细节呢？   


    1、构造器不能被继承
    2、方法和实例变量可以被继承
    3、子类构造器隐式地调用父类的默认无参构造器;
    4、如果父类中没有定义无参构造器，只定义了有参构造器，那么子类构造器则必须显式地调用父类的有参构造器(通过super(…))，且必须放置在第一条语句，否则会有语法错误。
    5、this()和super()在构造器中都必须为第一条语句，两者不能同时出现。
    6、当一个子类继承了一个父类后，父类中所有的字段和方法都被子类继承拥有，子类可以任意的支配使用，每个子类对象中都拥有了父类中的所有字段。当构造一个子类的实例对象时，该对象的实例变量包括了子类本身以及父类中的所有实例变量，实例方法也包括了子类和父类中的所有实例方法。
    7、子类构造器用来初始化子类中所有的实例变量，而父类构造器super(实参)用来初始化父类中所有的实例变量。
    所以在堆中为子类实例对象分配的内存区域中包括了子类和父类中所有初始化后的实例变量
    


十五. 方法覆盖（重写）
    1. 方法覆盖只存在于子类和父类(包括直接父类和间接父类)之间。在同一个类中方法只能被重载，不能被覆盖；
    2. 静态方法：
       不能覆盖；
       a. 父类的静态方法不能被子类覆盖为非静态方法 //编译出错
       b. 子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖)
  例如:A类继承B类 A和B中都一个相同的静态方法test
B a = new A();
a.test();//调用到的时候B类中的静态方法test
A a = new A();
a.test();//调用到的时候A类中的静态方法test
    可以看出静态方法的调用只和变量声明的类型相关
这个和非静态方法的重写之后的效果完全不同
       c. 父类的非静态方法不能被子类覆盖为静态方法；//编译出错
    3. 私有方法： 
       不能被子类覆盖
       class Base {
             private String showMe() {
                  return "Base";
             }


             public void print() {
                  System.out.println(showMe());
             }
       }


       public class Sub extends Base {
             private String showMe() {
                  return "Sub";
             }


             public static void main(String args[]) {
                  sub sub = new Sub();
                  sub.print();            
 //打印出结果"Base", 因为print()方法在Base类中定义，因此调用在Base类中定义的
                  //private类型的showMe(). 如将private换成public类型，其它代码不变，打印"Sub";
             }
       }
    4. 抽象方法：(之后会详细讨论抽象方法)
       可以覆盖：
       a. 父类的抽象方法可以被子类覆盖为非抽象方法： 子类实现父类抽象方法；
       b. 父类的抽象方法可以被子类覆盖为抽象方法：   重新声明父类的抽象方法；
       c. 父类的非抽象方法可以被子类覆盖为抽象方法； 
    
  


十六. super关键字


    1. 为什么要使用super关键字？


       1）子类中要访问父类方法或变量。
       2) 子类中调用父类的构造器
    2. 使用注意事项：
 
       a. 只能在构造方法或实例方法内使用super关键字，在静态方法和静态代码块内不能使用super关键字。
       b. 在子类构造方法中如没有使用this关键字，会隐式调用父类的无参构造方法；


          class Father() { 
public Father() {
//这里第一行隐含一句代码: super();
                       System.out.println("In Father()");
                }
          }


          class Son extends Father {
          }


          public class Test {
                 public static void main(String[] args) {
                        new Son(); //打印输出 In Father()
                 }
          }


          -----------------------------------------------------------------------


          class Father() { 
       public Father() {
                       System.out.println("In Father()");
                }
          }


          class Son extends Father {
                public Son() {
  //super();
                       System.out.println("In Son()");
                }
          }


          public class Test {
                 public static void main(String[] args) {
                        new Son(); 
                        //打印输出 In Father()
                        //         In Son()
                 }
          }
          
          -----------------------------------------------------------------------


          class Father() { 
       public Father(String name) {
                       System.out.println("In Father() " + name);
                }
          }


          class Son extends Father {
                public Son() {
  //super();
                       System.out.println("In Son()");
                }
          }


          public class Test {
                 public static void main(String[] args) {
                        new Son();  //编译出错, 子类会隐式调用父类中无参构造方法，而此时父类中不存在无参构造方法。
                 }
          }


          -----------------------------------------------------------------------


          class Father() { 
       public Father(String name) {
                       System.out.println("In Father() " + name);
                }
          }


          class Son extends Father {
                public Son() {
                       super("zs");
                       System.out.println("In Son()");
                }
          }


          public class Test {
                 public static void main(String[] args) {
                        new Son();  
                        //打印输出：
                        //In Father() zs
                        //In Son()
                 }
          }


          -----------------------------------------------------------------------


          class Father() { 
       public Father() {
                       System.out.println("In Father()");
                }


       public Father(String name) {
                       System.out.println("In Father(String name)");
                }
          }


          class Son extends Father {
                public Son() {
                       this("zs");
                       System.out.println("In Son()");
                }


                public Son(String name) {
  //super();
                       System.out.println("In Son(String name)");
                }
          }


          public class Test {
                 public static void main(String[] args) {
                        new Son();  
                        //打印输出：
                        //In Father()
                        //In Son(String name)
                        //In Son()
                 }
          }
       
       c. 构造方法中this(...)和super(...)不能同时出现；






十七. 多态
    多态的俩中描述:
    1.一个父类类型的引用可以指向他任何一个子类的对象
    2.[相同]类域的[不同]对象执行[同一]方法的时候会有[不同]的表现


    多态是出现在具有继承关系的两个类之间，所以它不像方法重载（发生在一个类中）在编译期间发生（也就是确定下来），而是在运行期间发生（确定下来）。
    Java中的方法是在代码运行时动态绑定的。
    


十八. 类型转换


    转换：
    1) 先使用instanceof 识别类型
    2) 子类型隐式地扩展到父类型（自动转换）
    3) 父类型必须显式地缩小到子类型


    转换规则：被转换的实际对象类型一定是转换以后对象类型的自身或者子类。
    Person p = new Person();
    Student s = (Student)p; 编译不会错，运行时错误


    Person p2 = new Student();
    Student s = (Student)p2 正确