J2SE第三章——面向对象（一）

类  对象  抽象类  接口   面向接口编程

 

分类概念：是整体概念 物以类聚  是抽象的

每个个体：分类中的每一个个体，起个名称，就是对象，也叫实例。  具体的

 

1.描述一个类

         类名 {

                   //静态层面    数据类型  变量名

                            Stringusername;  ----attribute

                            intage;

                            booleansex;

 

                   //动态层面

         }

 

类和类之间的关系：（3大种6小种）

使用：

拥有：

                  1.一般意义的拥有

                  2.整体部分的拥有

                  3.生命周期的拥有

继承/实现：

public class Person {          public void drive(Car car) {       //方法结束，变量就消失----局部变量                    car.run();          } }   public class Car {          public void run() {                    System.out.println("Car is running.....");          } } ------------------------------------ public class Person {          private Car car;              //car 是属于本人的-------成员变量            public void drive() {                    car.run();          }            public void Car {                    pulic void run() {                             System.out.println("Car is running");                    }          } }     ------------------------------------------ public class Person {          private Car car;            public Person(Car car) {                    this.car = car;       //同生共死。生命周期   构造函数          }            public void drive() {                    car.run();          }            public void Car {                    public void run() {                             System.out.println("Car is running");                    }          } }

 

 

类：类的定义主要有两个方面  成员变量和方法

                   次要：静态代码块

 

成员变量定义后有一个默认的初始值

                  对于数值型的默认值就是0

                  对于布尔型的默认值是false

                  对于引用型的默认值就是null （不确定）

 

！！！！！！！！！！！！！！！！！局部变量必须手动赋初值！！！！！！！！！！！！！！！！

 

2.对象：

         创建对象： 数据类型  对象名 =  new 类名();

public class Test {            public static void main(String[] args) {                    Person p1 = new Person();                    Person p2 = new Person();   //-----> Person p1; p1 = new Person();                                                                                     // new Person()创建一个Person类型的对象                                                                                     //属于该个体的每一个对象，都应该拥有类中定义                                                                                              //的用来描述这类静态层面信息的“属性--成员变量”                                                                                     //p1 = new Person();内存平面理解好像是：                                                                                    //把创建的对象  赋值给p1                                                                                     //引用型赋值是把对象占据内存的“逻辑地址”保存到                                                                                              //局部变量p1所标记的内存单元格                                                                                     //p1通过所存储的地址，（引用）指向在堆中对应的对象          }   }   class Person {          int age;          boolean sex;            public void eat() {                    System.out.println("Person is eating....");          } }

java中的对象是通过引用对其操作的。

变量p存储了对象的引用

变量p引用了某对象

变量p指向了某对象

变量p保存了对象的引用,所以通过p就能访问到该对象

 

访问对象p（所指向的对象）的eat方法

对象是通过变量访问的

 

p.age  变量p指向的对象的age.    通过.访问对象成员

 

同一个类的不同对象有不同的成员变量的存储空间

同一个类的每个对象共享方法（同一个方法反复调用，一个对象调用时方法加载到内存，

         方法结束内存释放。另一个对象再次调用该方法，方法再次加载到内存）

 

 

3.构造函数

 

Person p = new Person();

         根据约定 ()前如果没有空格，它就是一个方法的名称

         标识符命名首字母大写的名称是类名

         之前提到的eat方法run方法都是用来描述类的动态行为的。

         --> Person 的确是一个方法，而且该方法的作用是创建一个对象-->起个名称：构造方法（函数）

         构造函数的作用：创建对象   给成员变量赋值

 

         构造方法的名称和类名相同

         构造函数没有返回值类型-->因为调用某类的构造函数创建对象，对象的类型一定是这个类的类型

         方法是先定义再调用

         没有显示的定义构造函数，JVM会自动提供一个无参构造函数

         创建对象，其实就是调用某个类的构造函数

         无参构造函数：

                   使用无参构造函数创建对象，该对象拥有的属性取值都是默认初始值

                   Person() {}

 

         有参构造函数：

                   创建对象的同时为对象属性赋值,靠形参列表与无参构造函数区分---->方法重载

Person(boolean s) {                             sex = s;                    }                    public class Test {                             public static void main() {                                      Person p1 = new Person();                                        Person p2;                                      p2 = new Person(true);                             }                    }

         形式参数：方法定义时的参数（形参）---相当于局部变量---栈

         实际参数：方法调用时的参数（实参）

         调用构造函数，内存变换：

                   1.堆创建对象，属性值，默认值

                            栈 存储了形参s

                   2.因为方法调用时涉及了形参、实参

                            方法调用的同时，伴随着“实参”向“形参”的“值”传递

                            内存解析：

                                     实参：常量值true  形参：变量s   (s = true)

                   3.执行方法体：

                            sex= s;  把变量s存储的“值”赋给了变量sex  (就近原则)

                   4.方法执行完：方法中的局部变量或者形参作用域结束-->内存释放

                            回到方法调用的地方继续执行

                            把创建对象的引用保存到变量p2中

                   ----创建对象的同时，为对象属性赋值

public class BirthDate {          //三个成员变量          private int day;          private int month;          private int year;              //一个构造函数          public BirthDate(int d ,int m ,int y) {                    day = d;                    month = m;                    year = y;          }          //3对get set实例方法          public int getDay() {                    return day;          }            public void setDay(int d) {                      //方法内部没有找到day的定义                    //从内往外，一层层找                    //day 出现在setDay的内部，所以day就应该属于setDay()方法                    //setDay又是b.setDay调用的                    //所以day变量就是属于调用setDay方法的对象----b!!!                    day = d;          }            public int getMonth() {                    return month;          }            public void setMonth(int m) {                    month = m;          }            public int getYear() {                    return year;          }            public int setYear(int y) {                    year = y;          }            //实例方法          public void display() {                    System.out.println(day + "." + month + "," + year);          } }   public class Test {          public void change1(int i) {                    i = 1234;          }            public void change2(BirthDate b) {                    b = new BirthDate(22,2,2004);          }            public void change3(BirthDate b) {                    b.setDay(22);          }            public static void main(String[] args) {                    Test test = new Test();                        int date = 9;                    BirthDate d1 = new BirthDate(7,7,1970);                          BirthDate d2 = new BirthDate(1,1,2000);                      test.change1(date);                      // 实参向形参的值传递                    // 实参d1的值是什么呢？是(7,7,1970)对象的引用                    test.change2(d1);                      test.chang3(d2);                      System.out.println("date = " + date);  --> 9                      d1.display();  //7,7,1970                             } }

 

 

 

4.重载

public Person {          int id ;          boolean sex;            public Person() {            }            public Person(int i) {                    id = i;          }            public Person(boolean s) {                    sex = s;          }            public Person(int i;boolean s) {                    id = i;                    sex = s;          } }

 

需求=====>>>可以有如上不同的构造函数的定义

理论抽取：（方法定义：返回值  方法名  形参  方法体）

 

 

如果存在一组方法，满足下面的条件：

1.方法名称   相同

2.形参列表   不同(形参个数不同、类型不同、顺序不同 )

3.方法体     不要求

4.返回值类型不要求   返回值类型是由方法体决定的，方法体不要求，返回值类型就不要求

这种现象：方法的重载（OverLoad）