面向对象的概述
“面向对象”(英语：Object Oriented,简称OO)是一种以事物为中心的编程思想。面向对象程序设计（英语：Object-oriented programming，缩写：OOP），是一种程序开发的方法。它将对象作为程序的基本单元，将程序和数据封装其中，以提高软件的重用性、灵活性和扩展性。
面向对象时相对于面向过程而已的（c则是一个典型的面向过程的语言），站在面向对象的角度去看问题，你则是对象的动作的指挥者。如果站在面向过程的角度去看问题，你则是动作的执行者。
面向对象与面向过程对比
“万物皆对象”。
买电脑
面向过程
1：查资料
2：电脑城砍价
3：被黑
4：痛苦归来
面向对象
1：找对象。老师
2：老师.砍价
3：老师.检测电脑
4：电脑成功购买
面向过程
强调的是功能行为，面向过程”是一种以过程为中心的编程思想。“面向过程”他们不支持丰富的“面向对象”特性（比如继承、多态），就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。面向过程在这一系列工作的执行中，强调的是工作的执行。
对象
对象（object）代表现实世界中可以明确标识的一个实体。例如：一个学生、一张桌子、一间教室，一台电脑都可以看做是一个对象。每个对象都有自己独特的状态标识和行为
对象的属性（attribute，或者状态（state）），学生有姓名和学号，该学生特有的姓名和学号就是该学生（对象）的属性。
对象的行为（behavior），是由方法定义，调用对象的一个方法，其实就是给对象发消息，要求对象完成一个动作。可以定义学生对象具备学习的行为。学生对象可以调用学习的方法，执行学习的动作
面向对象的特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。
设计的过程：其实就是在管理和维护对象之间的关系.
使用java来描述事物
案例：通过Java语言定义一个汽车类，并生产出汽车，有颜色，轮胎个数， 有运行的功能。
分析：
如何描述现实世界中的事物，描述该事物的属性和行为，汽车具有颜色和轮胎数的属性，具备运行的行为。
如何使用Java语言进行转换？
根据对应关系：
属性：类中的成员变量
行为：类中的成员函数
那么定义Java类就是定义一个类的成员。汽车类具备的成员是：颜色，轮胎数，运行方法。
Car类定义流程：
1.使用class 关键字 定义类，
1.class空格 类名。类名就是标识符，命名规则，单词的首字母大写，多个单词的首字母大写。注意：不是规定，但是最好遵守
2.类名后紧跟一对{}表示类的开始和结束。
2.汽车有轮胎数 int num;
1.不需要给num初始化值，因为汽车轮胎数不确定，有4，有6，有8。
3.有颜色 String color
1.为什么使用String 例如定义颜色”红色”是字符串类型。
2.也不需要初始化值。
4.跑的行为(方法、函数) void run(){}
1.方法中执行输出语句。syso(“跑啦。。。。”);
public class Car {
String color;// 成员变量
int num; // 成员变量
// 成员函数
void run() {
System.out.println(color + "的车，轮胎数：" + num + "个，跑起来了");
}
}对象的创建
创建Car对象
1.使用new关键词，就像new数组一样
2.需要给型的汽车起一个名字，car
3.变量都是有类型的，car属于什么类型，属于Car类型，叫做类类型
4.Car car=new Car();
图纸画好了，类定义成功了。如何根据图纸生产汽车，在Java中如何根据类来生产一个对象。
Java中生产汽车比较简单，通过一个关键字”new”, 通过 new Car(); 就在内存中产生了一个实体，汽车对象就生产出来了。
汽车对象生产出来后，还没有名字，为了方便使用，需要起一个名字。就用小写的C 来表示新车的名字。
Java中的变量都需要有类型。那么c 是什么类型呢？c 是Car类型，所以c也叫做类类型变量。
class CarDemo {
public static void main(String[] args) {
// java 中创建对象，使用new关键字。在堆内存中开辟了空间。产生了一个实体。
Car c = new Car();
//为了方便使用生产的汽车，就起了一个名字。
//那么c是什么类型,是Car类型。叫做类类型变量。
//注意 c是持有的引用，新生产的汽车并没有直接赋值给c，持有的只是一个引用。c就想电视遥控器一样。
c.run(); //使用对象的功能。
}
}对象成员的调用
有了car对象，调用对象成员
1.成员变量
2.成员方法
public class CarDemo {
public static void main(String[] args) {
Car c = new Car();
//对象名.成员变量名将返回成员变量中存储的数值
int num=c.num;
System.out.println(num);
//对象名.成员变量名,也可以给成员变量赋值
c.num = 4;
c.color = "black";
//对象名.成员方法();
c.run();
}
} 局部变量和成员变量
成员变量: 定义在类中变量
局部变量: 定义在方法中变量
成员变量与局部变量的区别：
1.应用范围
1.成员变量在整个类内都有效
2.局部变量只在其声明的方法内有效
2.生命周期
1.成员变量: 它属于对象，它随着对象的创建而创建，随着对象的消失而消失
2.局部变量: 使用完马上释放空间。
void show(int id){
for(int i=0;i<10;i++){
for(int j=0;j<10;j++){
System.out.println(id);
}
}
}
这时候 id,i,j者是在方法内声明的，全是局部变量
j当里层for循环执行它的生命周期开始，当里层for结束，j消失
i当外层for循环执行它的生命周期开始，当外层for结束，j消失
id在方法被调用时开始，方法结束时，id消失.
3.存储位置 成员变量属于对象，它存储在堆内，堆内的实体，当没有引用指向其时，才垃圾回收清理 局部变量存在栈内存中，当不在使用时，马上就会被释放。
4.初始值
成员变量它存储在堆中，如果没有赋初值，它有默认值。
1.整数byte、short、int、long =0；
2.char='\uoooo'；
3.boolean =flase；
4.String =null;
5.类类型 =null；
6.数组 =null；
局部变量，如果要想使用必须手动初始化.
i.方法中，参数列表中，语句中。
ii.必须给初始化值，没有初始值，不能使用
iii.在栈内存中案例一：
//汽车
class Car {
//汽车应该具备的属性
int num;
//汽车具备的颜色
String color;
//汽车跑的行为
public void run(){
System.out.println(num+"轮子的汽车跑起来啦");
}
}
public class CarDemo{
public static void main(String[] args)
{ //创建实体，并且给该实体起一个名字
Car c = new Car();
c.color = "red";
c.num = 4;
c.run();//指挥车进行运行。调用格式：对象.对象成员
}
}案例二：
public static void main(String[] args)
{ //创建实体，并且给该实体起一个名字
Car c = new Car();
Car c1 = new Car();
c.color = "red";
c1.num = 4;
System.out.println(c1.color);
c.run();//指挥车进行运行。调用格式：对象.对象成员
}案例三：
public static void main(String[] args)
{ //创建实体，并且给该实体起一个名字
Car c = new Car();
Car c1 = c;
c.color = "red";
c1.num = 4;
c1.color = "green";
System.out.println(c1.color);
c.run();//指挥车进行运行。调用格式：对象.对象成员
}匿名对象
匿名对象：没有名字的实体，也就是该实体没有对应的变量名引用。
匿名对象的用途
1，当对象对方法进行一次调用的时候，可以使用匿名对象对代码进行简化。
为什么只对方法，而不调用属性呢？因为匿名对象调用属性没意义。
如果对象要多成员进行多次调用，必须给对象起个名字。不能在使用匿名 对象。
2，匿名对象可以实际参数进行传递。
匿名对象的简单演示
1：new Car().run();
内存结构图
1：new Car().num=5;
2：new Car().clor="blue";
两个new 是两个不同的对象，在堆内存中有不同的空间，相互不相互干扰。
匿名对象的使用
1：当只使用一次时可以使用匿名对象。执行完毕到;后该对象就变成了垃圾。
new Car().run();
执行方法时，可以将匿名对象作为实际参数，传递进去。
5:修黑车
1：需求
将小汽车改装成3个轮子的黑车。
1：汽车类。
2：汽车修理厂/*
匿名对象
匿名信
修黑车
汽车类
黑车厂类
把汽车的改成黑色3轮车。
*/
class Car {
String name = "smart";
String color = "red";
int num = 4;
void run() {
System.out.println(name + ":" + color + ":" + num + ":跑起来了。。。。");
}
}
class BlackCarFactory {
String name;
String addr;
Car repairCar(Car c) {
c.num = 3;
c.color = "黑色";
System.out.println("改装成功啦。。。");
}
}
class Demo1 {
public static void main(String[] args) {
BlackCarFactory bcf = new BlackCarFactory();
bcf.name = "幸福修理厂";
bcf.addr = "天河区棠东东路御富科贸园a栋206";
// 非匿名对象
Car c = new Car();
c.run();
// 改装
bcf.repairCar(c);
// 取车
c.run();
// 匿名对象一,只使用一次：
// 如下创建了2个对象
/*
* new Car().run();
*
* new Car().run();
*/
// 匿名对象二，作为实际参数传递
Car c2 = bcf.repairCar(new Car());
c2.run();
System.out.println();
}
}