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）