赵雅智_java类和对象（未完待续）

面向对象编程初步

编写程序对一个问题求解的过程 --> 定义类和对象的过程

类和对象

                                                                                        自己招标，建筑图纸，抽象，模版      找公司招标，某个大楼，具体，实例

                                                      OOA,OOD                                         实例化

                                         要求解的问题  ----------------->类、类之间的联系------------->对象

  抽象

对象：张三，20，CSDN，保定

            李四，19，软件系，湖南

类：   学生：姓名，年龄，系别，籍贯 ---------  属性：静态

           注册，学习                                     ---------  行为：动态

对象：构成系统的最基本的单位。

对 |-　属性（变量）：描述对象的静态特征
象 |-　行为（方法）：描述对象的动态特征

类：一批具有相同属性行为的对象的抽象。

 类

[修饰符] class 类名{

        //成员变量（定义该类或该类的实例（对象）所包含的数据）
        //构造方法（构造该类的实例，通过new来调用构造方法，从而返回该类的实例）
        // 成员方法（行为特征或功能实现）
}       

注意：

[ 修饰符 ]可以是：[ public    ]   公共类（可以从其它类中访问）
                                 [ abstract ]   抽象类（不能用new实例化一个对象）
                                 [ final        ]    最终类（不能被其他类继承）
                                 [ 默认       ]   friendly类（只能被本包中的类使用）

 成员变量

[修饰符] 类型 成员变量名[=初始值];

修饰符：[public | protected | private ] [ static ] [ final ]

注意：

变量名：一个或多个有意义的单词组合而成，第一个单词首字母小写，后面每个单词首字母大写。

成员方法

[修饰符]  返回值类型  方法名([形式参数表])

{          //  方法体； }

修饰符： [ public | protected | private ] [ static ] [ abstract | final ]

返回值类型：任何数据类型，声明了返回值类型，return语句，返回一个变量或表达式的值，变量或者表达式的类型必须与方法返回值类型匹配；）
                                                    没有返回值，void来声明。

方法名：命名规则与变量名的命名规则基本相同，但通常建议方法名以英文中的动词开头。

形参列表：多组参数之间，用“，”隔开。

static：类公用的

可用于修饰：方法、变量等成员。

static声明的：类公用的、类方法（变量）、实例方法（变量）、静态方法（变量）

非......声明的：单个实例、非静态方法（变量）

静态成员不能直接方位非静态成员。

构造方法

构造方法没有返回值，不需void来声明；

当该类被实例化时，构造方法自动被调用。因此，构造函数的作用—对类对象中的成员进行初始化。

[修饰符（public,protected,private）]  类名（和类名相同） ([形参列表]){
  //构造方法的方法体
}

重载：（参数不同）

Car(){ };
Car( String s){ };
Car( Color c, String s){ };
Car c2 = new Cae();错误

不写构造方法：系统自动提供一个默认的构造方法；

写了................：........不再............................................。

public class Car{public String name; public String color;                         //变量public Car(String name1,String color1){name=name1;        color=color1;    //构造方法}public void run(String speed){System.out.println(speed);          //其他方法}}

对象的创建

构造方法，通过new调用某个类的构造方法。
      Car c;
      c=new Car("QQ","黄色");

 如果有访问权限

类名.变量名         或      类名.方法名（[形参列表]）

 对象名.变量名     或      对象名.方法名（[形参列表]）

static：两种都行

非.... .：对象调用

public class TestCar{   public static void main(String args[]){         Car c;                              //定义Car变量          c=new Car("奔驰600","黑色");      //通过new调用构造方法，返回Car实例          c.run("100km");                    //调用c的run方法，输出汽车速度          System.out.println(c.name)      //直接访问c的name变量值   }}

结果：

100km,奔驰600

内存的存储情况：

句柄、引用 

_________             _______________

|  ----------    |             |0088________    |
|  | 0088 | --|----------|---->| name=n  |    |
|  ----------    |             |        ---------------    |
|                   |             |         |color=c     |   |
|                   |             |         ---------------    |
|                   |             |                                 |
|    地址       |             |                                 |

public class TestCar2{   public static void main(String args[]){Car c1;                                  //定义Car引用变量c1 = new Car("奔驰600","黑色");           //通过new调用构造方法，返回Car对象Car c2 = c1;c2.name = "宝马7";c2.color = "黑色";c2.run("1000km")                         //调用c2的run方法System.out.println(c1.name);             //直接输出c1的name变量值和color变量值System.out.println(c1.color);       }}结果：宝马7，1000km

结果：宝马7，1000KM

Car c1，c2;

c1=new Car("奔驰600","银灰色");
c2=c1;
c1.name和c2.name访问的是同一个对象中的name成员。

 

当c1=null；c2=null;则：

对象的声明周期

1.对象的创建

类名 变量 [=new 类的构造函数（实参）] Car obj=new Car(“奔驰600”,“银灰色”)；

2.对象的使用

变量 [=new 类的构造函数（实参）] Car obj=new Car(“奔驰600”,“银灰色”)；
对象名.成员变量名 或 对象名.成员方法名(实参表) obj.name=“宝马”; 或 obj. run(100);

3.对象的销毁

类名 如果对象(实例)的使命完成，应该将其被从内存中删除。
当某个对象不在被任何引用变量引用时，该对象将被清除
通过内存垃圾自动收集机制(finalizer)清除无用对象。

 构造方法的重载

当一个类有多个重载的构造方法时，创建该类对象的语句会根据给出的实际参数的个数、参数的类型、参数的顺序自动调用相应构造方法。

public class Car{String name,color; public Car(){name=“汽车”;color=“black”;                     }public Car(String n,String c){name=n;color=c;}}

Car c1=new Car();

Car c2=new Car(“夏利”,”绿色”);

 

 this
自身的引用

作用：在类的自身方法中引用该类自身。

public class Car{public String name，color;public int oil;public Car(String name1,int getOil){this.name=name1;              //构造方法中的this就代表奔驰对象本身。

this.oil=getOil;}public void run(int speed){this.oil-=speed;  System.out.println(speed);//run方法中的this就代表奔驰对象本身}

}

在同一个类中，类的成员变量是不能重名的，但方法或语句块中的局部变量是可以和类的成员变量重名的，这时候必须使用this来限定和区分是否是类变量。
 public class Car{
 public String name，color;
 public int oil;
 public Car(String name,int oil){
  this.name=name; this.oil=Oil;
 }
 public void run(int speed){
  int oil=speed;
                     this.oil-=oil;  System.out.println(speed);
 }
}
方法间的互相应用也可以使用this关键字 public void highRun(int speed){           int highSpeed=2*speed;           this.run(highSpeed); }
this引用也可以用于构造方法中作为默认引用
例4.6使用this引用调用其它构造方法。