一、面对过程和面对对象
1、面对过程
面对过程的程序设计思想 又简称(POP)
其关注的焦点在过程：过程就是操作数据的步骤，当过程中的实现代码出现大量重复出现，可以用将这个过程抽取为函数，使复杂的代码被大大的简化，方便维护。
经典的语言：c语言。
代码结构：是以函数为组织单位。
特点：是一种执行者思想，适合解决简单的问题，
将一个问题分解为一个个步骤，然后逐个解决，
代码的扩展性弱，不方便维护。
2、面对对象
面对对象的程序设计思想 又简称(OOP)
其关注的焦点在类：在计算机程序设计过程中，类是对现实事物的属性特征、行为特征进行抽象概括的描述。
典型的语言：Java、C#、C++、Python、Ruby和PHP等。
代码结构：是以类为组织结构，每一种事物都具有自己的 属性 和 行为 / 功能。
特点：是一种设计者思想，适合解决复杂问题。
代码扩展性强，方便维护
3.思维的区分
例一：如何开车
只需分为 汽车打火------->踩离合，松手刹，挂挡------->松离合，踩油门------->汽车行进
这就是利用面对过程的思想将开车这个问题分为几步依次进行，面对过程适用于简单，不需要相互协作的问题。
例二：如何造车
这里就不能思考“如何按特定的步骤进行造车”而是“怎样造车”，这就是面对对象的思想，所以面对对象的思想更契合人的思维方式。
这里将“怎样造车”分为：发动机、底盘、座椅、玻璃、轮胎、车壳，这几个步骤，这几个步骤又通过面对过程的思维进行分解，最后可以得到一辆车。
这个例子可以体现出面对对象是对事物宏观上的理解，面对过程是微观上的体现。
当需求单一，或者简单时，我们一步步去操作没问题，并且效率也挺高。 可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就需要开始思索，能不能把这些步骤和功能进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
注意： 面对对象与面对过程是相辅相成的，面对对象离不开面对过程。
例三：人将大象关进冰箱
面对过程
1.人打开冰箱
2.大象关进冰箱
3.人关闭冰箱面对对象
人{
打开(冰箱){
冰箱.开门()；
}
操作(大象){
大象。进入(冰箱)；
}
关闭(冰箱){
冰箱.关门()；
}
}
冰箱类{
开门(){}
关门(){}
}
大象类{
进入(冰箱){ }
}二、类和对象
类(Class)和对象(Object)是面向对象的核心概念
什么是类？
类：具有相同特征的事物的抽象描述，是抽象的、概念上的定义。
什么是对象
对象：实际存在的该类事物的每个个体，是具体的，因而也称为实例。
可以理解为：
类 => 抽象概念的人；对象 => 实实在在的某个人
类=>汽车图纸; 对象=>实际存在的一辆汽车,拥有类中定义的功能,可以被使用
1.类的结构
变量：事物属性的描述(名词)
方法:事物的行为（可以做的事情 动词）
构造方法：初始化对象
块：一段没有名称的代码块
内部类： 即在类体中声明的类
第一步：发现类
根据不同类型的车,抽象出“车类” 各种车
类的声明格式为:
[访问权限修饰符] [修饰符] class Car{
}
访问修饰符有两种public，无(默认)
修饰符：final,abstract
关键字class用来定义一个类
Java类名的命名规范: 类名首字母大写,见名知意,驼峰表示
第二步：发现类的共有属性(成员变量)
package day1.Cardemo;
public class Car {
/*成员变量(因为变量直接定义在类中，所以称为类的成员)
名词 属性
成员变量在类中定义时，可以不给其默认值，系统会自动初始化赋值
默认值：引用类型 - null
float - 0.0
int long - 0
boolean - false
char - ' '
*/
String name;
float price;
String color;
}声明成员变量的格式为： [访问权限修饰符] [修饰符]
成员变量是定义在类中，方法体之外的变量。
成员变量可以使用Java语言中任何一种数据类型（包括基本类型和引用类型）。
在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。
成员变量可以被类中方法、构造方法和特定类的语句块访问。
成员变量的作用范围为整个类体。
第三步：发现类的共有行为(成员方法)
package day1.Cardemo;
public class Car {
String name;
float price;
String color;
/*成员方法
*/
public void run(){
System.out.println("汽车开始行驶");
}
public void stop(){
System.out.println("汽车停止");
}
public void showInfor(){
System.out.println(" 姓名 :"+name+" 价格 :"+100000000+" 颜色 :"+color);
}
}2.如何创建并使用对象
kage day1.Cardemo;
public class TestCar {
public static void main(String[] args) {
/*
什么是对象
对象是类的实例，是以类为模板，在内存中创建出的一个实际存在的实例(对象)
如何创建对象
使用new关键字，Car()--类的构造方法，类中会自动提供的
new Car() 使用new关键字创建一个具体的对象，对象存在内存中
Car bm/lsls(引用变量) 声明一个Car类型变量
= 把右边创建的对象内存的地址赋给左边的变量，左边的变量就可以表示内存中的对象了。
类和对象的关系
*/
/*
类是抽象定义的概念，如果要调用，需要定义一个类的实例
类名 什么都调用不了
*/
/*
类是模板，是定义
对象是具体实例
万事万物(具体存在)皆为对象
*/
/*同一类的每个对象有不同存储空间。
对象是类的一个实例，必然具备该类事物的属性和行为（即方法）。
使用对象名.属性或对象名.方法的方式访问对象成员（包括属性和方法）
*/
Car bm = new Car();
bm.name = "宝马";
bm.price = 300000;
bm.color = "白色";
bm.stop();
bm.showInfor();
Car lsls = new Car("劳斯莱斯幻影",100000000,"黑色");
Car lsls2 = new Car("劳斯莱斯幻影","红色",100000000);
lsls.run();
lsls.stop();
lsls.showInfor();
}3.总结类与对象
总结类和对象 类是一类事物的抽象概念,是一个模型. 对象是由这个模型所创造的,一个个具体存在的,实实在在存在的实例. 所以创建对象的过程也叫实例化对象.
现实生活中先有对象后有类,而编程时先设计类后创建对象.
三、构造方法
package day1.Cardemo;
public class Car {
String name;
float price;
String color;
/*
构造方法
功能 构造方法名与类名相同，没有返回值，不需要使用void修饰
作用 在构造方法中为创建的对象成员变量初始化赋值
特点 每一个类都有构造方法，如果没有显式地为类定义构造方法，java中将会为该类提供一个默认的无参构造方法，
public {
String name = null;
float price = 0.0;
String color = null;
}
但是只要定义了一个有参构造方法，默认的无参构造方法就会失效
所以如果定义一个有参构造方法后还需要无参构造方法时，需要重新定义一个无参构造方法
由方法重载可以引出一个类可以有多个构造方法
*/
public Car(){
}
public Car(String n,float a,String g){
String name = n;
float price = a;
String color = g;
}
public void run(){
System.out.println("汽车开始行驶");
}
public void stop(){
System.out.println("汽车停止");
}
public void showInfor(){
System.out.println(" 姓名 :"+name+" 价格 :"+100000000+" 颜色 :"+color);
}
}
四、方法的重载
方法的重载是指一个类中具有相同的名字，但参数不同的多个方法。 l参数不同（可以有三方面的不同）
数量不同
类型不同
顺序不同
调用时，会根据不同的参数表选择对应的方法。
注意：方法重载跟方法的返回值类型没有任何关系
package day1.Cardemo;
public class Car {
String name;
float price;
String color;
public Car(){
}
//方法重载
public Car(String n,float a,String g){
String name = n;
float price = a;
String color = g;
}
public Car(String n,String g,float a){
String name = n;
float price = a;
String color = g;
}
//方法重载
public void run(){
System.out.println("汽车开始行驶");
}
public void run(String rate){
System.out.println("汽车以"+rate+"开始行驶");
}
public void stop(){
System.out.println("汽车停止");
}
public void showInfor(){
System.out.println(" 姓名 :"+name+" 价格 :"+100000000+" 颜色 :"+color);
}
}
五、对象与引用
（1）右边的“new Car()”，是以Car类为模板,在堆空间里创建一个Car类对象。
（2）左边的“Car bm”创建了一个Car类型引用变量。所谓Car类的引用，就是以后可以用来指 向Car对象的对象引用。
（3）”=”操作符使对象引用指向刚创建的那个Car对象。 我们可以把这条语句拆成两部分：
Car bm;
bm= new Car();
这样写，就比较清楚了，有两个实体：一个是对象引用变量，一个是对象本身
new Car(); 这个语句在堆空间里创建了实体，尽管它们也是确确实实存在的实体，但是， 我们看不见，也摸不着。
对象没有名字，也就没法直接访问它。我们需要通过对象引用来间接访问对象。
对象好比是一只很大的气球，但是我们抓不住它。引用变量是一根绳，可以用来系汽球。
Car car1; （1）创建一根绳子，一根还没有系上任何一个汽球的绳；
Car car2;（2）又做了一根绳，还没系上汽球，
car1 = new Car();（3）给car1 系上气球；
car2 = car1 ；（4）这里，发生了复制行为。要说明的是，对象本身并没有被复制，被复 制的只是对象引用。
结果是，car2也指向了car1所指向的对象。两根绳系的是同一只汽球
值传递
java中进行方法调用时传参分为两种
第一种 值传递（形参数类型是基本数据类型）：
方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容，是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。
package day2.value;
public class Test1 {
/*
形参改变后，实参是没有影响的
*/
public static void main(String[] args) {
int a = 10;
Test1 test = new Test1();
test.test1(a);
System.out.println("a="+a);
}
public void test1(int b){
b = 20;
System.out.println("b="+b);
}
}
第二种 引用传递 (形参数类型是引用数据类型参数)：
也称为传地址。方法调用时，实际参 数是对象，这时实际参数与形式参数指向同一个地址，在方法执行中，对形式参数的 操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法 执行中形式参数的改变将会影响实际参数。
package day2.value;
public class Test2 {
/*
引用类型传递-- 引用数据类型作为参数传递， 传递的只是对象的地址， 实参和形参指向的是同一个对象，
任何一方改变对象的值，另一方也会改变
*/
public static void main(String[] args) {
Cat cat = new Cat();
cat.name = "小白";
Test2 a = new Test2();
a.test2(cat);
System.out.println("小猫叫："+cat.name);
}
public void test2(Cat c){
c.name = "花花";
System.out.println("小猫叫："+c.name);
}
}
基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。 但是无论是值传递还是引用传递,其本质都是传值,所以也都统称值传递。
221
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
