接上期Java 面向对象

chp5.面向对象

一、面向对象思想（Object Oriented Programming）：

1.   一切客观存在的事物都是对象,万物皆对象.

2.   对象一定具备自己的特征(属性)和行为(方法).

3.   从面向过程编程(从过程开端入手,逐一完成功能)转换到面向对象编程(分析,构         建对象,以多个对象所具有的能力合理调用协同完成功能).

4.   将数据及对数据的操作作为一个相互依存，不可分割的整体。（数据的载体）

     

二、类：

1.   概念：

I.   在多个相同或类似的对象中，抽取出共性特征和行为，保留所关注的部分。

II.  类是对象的集合（模板）。

 

2.   组成：

I.   属性：

a.   成员变量（实例变量）：声明在类的内部，函数的外部。当通过类构建对       象的同时，所有成员变量都成为当前对象不可分割的特征。

b.   语法：数据类型 变量名;  //定义在类中

c.   成员变量和局部变量的区别：

	局部变量	成员变量
定义位置	函数或函数中结构的内部	类的内部、函数的外部
默认值	无默认值	字面值（与数组相同）
使用范围	从定义行到包含其代码块结束	本类
命名冲突	不允许重名	可与局部变量重名，局部优先

注意：如成员变量的声明和赋值分开完成，则赋值语句必须在函数内部。

 

II.  方法：

访问修饰符 返回值类型 方法名称( 形参列表 ){

//方法主体

}

 

III. 方法重载（Overload）：

a.   概念：方法名称相同，参数列表不同（类型不同、个数不同、顺序不同）。

b.   作用：屏蔽使用差异，使用方式灵活、方便。

 

IV. 构造方法：

a.   构造方法与类名完全相同。

b.   没有返回值类型。

c.   创建对象时，出发构造方法的调用，不可通过句点手动调用。

d.   注意：

1). 在类中，如果没有显示定义构造方法，则JVM默认提供无参构造方       法。

2). 如果手动添加了构造方法，则无参构造不再默认提供，根据需求手动            添加。

3). 构造方法也可重载，多个构造方法遵循重载的规则。

4). 通过关键字new对象时，根据传入参数，调用其对应的构造方法，完            成对象的创建。

5). 有参构造方法可在创建对象的同时，为其属性赋值。

构造方法的为了创建对象的。

有参构造方法是为了更方便的创建对象的。

 

三、对象：

1.   概念：

I.   具有多个特征和行为的实体。

II.  对象是类的实例。

 

2.   创建对象：

I.   分配空间：栈空间分配变量空间，堆空间分配对象空间。

II.  初始化属性：

a.   基本数据类型初始值为字面值。

b.   引用数据类型初始值为null。

 

四、访问属性和方法：

1.   引用（reference）中保存对象的地址。

2.   通过引用值的地址访问对象的属性和方法：

Dog d1 = new Dog();

d1.breed = "哈士奇"; //调用引用指向的实际对象的breed属性

d1.run(); //调用引用指向的实际对象的run方法

 

五、this关键字：

1.   引用（当前实例）：当成员变量和局部变量重名时，默认优先使用局部变量。如       需使用成员变量的话，应当增加this关键字作为前缀。如：this.name

2.   构造（首行）：在构造方法内部访问同一个类中的其他构造方法时，应在方法的       首行使用this()或this(实参)调用。

 

六、方法参数传递规则：

1.   基本数据类型为值传递（值的副本），两者间有一方发生改变，不会影响另一方。

2.   引用数据类型为引用传递（地址），两者间有一个发生改变，会影响另一方。

 

七、面向对象的特点：

1.   高内聚（在一个模块中，各个元素必须结合的紧密程度），指一个软件模块是由       多个相关性很强的代码组成，只负责一项任务，单一只能原则。

 

2.   低耦合（也叫块间联系，模块之间的紧密程度），各个模块可以独立存在，必须       间不存在必然联系，使用时通过组合完成任务。

 

3.   重用性（不必重复开发代码）。

4.   扩展性（重新组合、添加功能）。

bank    值传递（方法参数为基本数据类型）、引用传递（对象、数组、对象数组）

/*
java面向对象的语言


对象：真实存在唯一的事物。


类： 实际就是对某种类型事物的共性属性与行为的抽取。  抽象的概念....   车


我们从小的时候就不断的接触很多的对象，我们的大脑就会把
这些具备相同属性与行为的事物进行分类。


在现实生活中就存在对象与类这两种事物。计算机是服务于人类，为了让计算机更加接近我们的
生活，这时候就出现了面向对象的计算机语言。



面向过程（C）                  面向对象（java）




现实生活中 : 对象---------类


在java中： 类------------>对象




面向对象的计算机语言核心思想： 找适合的对象做适合的事情。




如何找适合的对象：
1. sun已经定义好了很多的类，我们只需要认识这些类，我们就可以通过这些类创建对象使用。 
2. 自定义类，通过自定义类来创建对象使用。




自定义类创建对象的三步骤：
1. 自定义类。
格式：
class 类名{

事物的公共属性使用成员变量描述。

事物的公共行为使用函数描述。
}


2. 通过自定义类创建对象。
格式： 
类名 变量名 =  new 类名();

3. 访问(设置)对象的属性或者调用对象的功能。
1.访问对象属性的格式：
对象.属性名.
2.设置对象的属性：
对象.属性名 = 数据。
3. 调用对象的功能
对象.函数名();
*/

//车类
class Car{

//事物的公共属性使用成员变量描述。
String name; //名字的属性


String color; //颜色属性


int wheel; //轮子数

//事物的公共行为使用函数描述。
public void run(){
System.out.println(name+"飞快的跑起来啦...");
}
}

class Demo1 
{
public static void main(String[] args) 
{
/*
//使用了Car类声明了一c变量， c变量指向了一个车对象。
Car c = new Car(); 
//设置车对象的属性值。
c.name = "BMW";
c.color = "白色";
c.wheel = 4;
//访问车对象的属性值
System.out.println("名字："+ c.name+" 颜色:"+ c.color+" 轮子数："+c.wheel);
c.run();
*/


Car c1 = new Car(); 
c1.name = "宝马";
Car c2 = new Car();
c2.name = "大众";
c1 = c2; 
System.out.println("名字："+ c1.name);  //大众  大众 \大众
}
}

/*


需求： 使用java描述一个车与修车厂两个事物， 车具备的公共属性:轮子数、 名字、 颜色 ，还
具备跑的功能行为。跑之前要检测轮子是否少于了4个，如果少于了4个，那么要送到修车厂修理，
修车厂修理之后，车的轮子数要补回来4个。 然后车就继续的跑起来。


修车厂： 具备公共属性： 名字、 地址、 电话。
公共的行为： 修车。


初学者的经典错误：
1. 变量在同一个作用域(大括号)上是可以直接访问的。
2. 如果一个类要访问另外一个类变量时，那么这时候就只能通过创建对象进行访问。（仅对于目前正确）
*/

//车类
class Car{

//事物的公共属性使用成员变量描述
String name ; // 名字


String color; //名字


int wheel; //轮子数

//事物的公共行为使用函数描述
public void run(){
if(wheel>=4){
System.out.println(name+wheel+"个轮子飞快跑起来..");
}else{
System.out.println(name+"不够4个轮子了，赶快去修理");
}
}
}

//修车厂
class CarFactory{

String name;//名字

String address ; //地址

String tel; //电话


//修车公共行为 ------ 返回值类型、 未知的参数
public void repair(Car c){
if(c.wheel>=4){
System.out.println("告诉你，费了很大力气修好了，给钱");
}else{
c.wheel = 4;
System.out.println("修好了，给钱!!");
}
}
}

class Demo2 
{
public static void main(String[] args) 
{
/*
//0x98
Car c = new Car();
//给车对象赋予属性值
c.name = "陆丰";
c.color = "黑色";
c.wheel = 4;

for(int i = 0 ; i<100 ; i++){
c.run();
}
c.wheel = 3;
c.run();


//创建修车厂对象
CarFactory f = new CarFactory();
//给修车厂赋予属性值
f.name = "集群宝修车厂";
f.address = "韵泰商业广场一楼";
f.tel = "020-1234567";

//调用修车的修车
f.repair(c);//0x98
//
c.run();
*/


//需求： 调用一次repair方法。  前提： 该对象调用完一个方法之后，这个对象就不再使用了。

}
}

/*
成员变量与局部变量的区别:

定义的位置上区别：
1. 成员变量是定义在方法之外，类之内的。
2. 局部变量是定义在方法之内。

作用上的区别：
1. 成员变量的作用是用于描述一类事物的公共 属性的。
2. 局部变量的作用就是提供一个变量给方法内部使用而已。

生命周期区别：
1. 随着对象 的创建而存在，随着对象的消失而消失。
2. 局部变量在调用了对应的方法时执行到了创建该变量的语句时存在，局部变量一旦出了自己的作用域
那么马上从内存中消失。

初始值的区别：
1. 成员变量是有默认的初始值。
数据类型     默认的初始值
int                0
float              0.0f
double              0.0
boolean            false
char                 ' '
String（引用数据类型） null

2. 局部变量是没有默认的初始值的，必须要先初始化才能使用。


*/


//人类
class Person {

String name; //成员变量


public void eat(){
int age ;


age = 12;
for(int i =  0 ; i< 5 ; i++){
System.out.println("hello world"+ age);
}
}


}

class Demo3 
{
public static void main(String[] args) 
{
Person p1 =  new Person();
p1.eat();


}
}


/*
匿名对象：没有引用类型变量指向的对象称作为匿名对象。


需求： 使用 java类描述一个学生类。


匿名对象要注意的事项：
1. 我们一般不会给匿名对象赋予属性值，因为永远无法获取到。
2. 两个匿名对象永远都不可能是同一个对象。




匿名对象好处：简化书写。

匿名对象的应用场景：
1. 如果一个对象需要调用一个方法一次的时候，而调用完这个方法之后，该对象就不再使用了，这时候可以使用
匿名对象。

2. 可以作为实参调用一个函数。
*/


//学生类
class Student{

int num; //学号


String name; //名字

public void study(){
System.out.println("好好学习，为将来称为高帅富做准备!");
}
}


class Demo4{


public static void main(String[] args) 
{
//创建一个学生对象
//Student s = new Student();
//new Student().name = "狗娃"; //匿名对象 
//System.out.println(Student().name); //null
System.out.println(new Student() == new Student()) ;  // "==" 用于引用类型变量时，比较的是内存地址。判断两个 对象是否为同一个对象

需求： 调用Student的study方法。


Student s = new Student();
s.study();

new Student().study();


}
}