生活中什么是面向对象
洗衣服，吃饭
面向过程：关注点是过程 ————站在一个执行者的角度去考虑事情，做事情
//step1.找个盆
//step2.收集要洗的衣服
//step3.放水，放洗衣粉。。
//step4：洗一洗
//step5：晒一晒
面向对象：关注点是对象 ————站在指挥者的角度
//step1：找个对象
//step2：让他洗衣服
生活中的面向对象：找合适的人，做合适的事儿。。
生活中的面向过程：亲力亲为，按照流程步骤来，一步一步，吭哧吭哧。。。
代码中：
Arrays类
sort();-->排序
binarySearch();-->搜索
Scanner类
sc.nextInt();
sc.next();
sc.nextDouble();
面向对象和面向过程
面向对象：(OOP)
不是一种语言，而是一种编程思想。
面向对象程序设计：(Object Oriented Programming)
Object：对象
Oriented：方向，定向
Programming：程序
面向过程：
关注点在过程上(步骤)
step1，step2，step3.。。。。
总和分析，按照步骤实现即可。
面向对象：
关注点在对象上
万事万物皆对象。
A：分析当前的问题域中所涉及的对象。
B：这些对象有什么样的特征和功能。
外部特征：静态属性
动作行为：动态属性
C：对象和对象之间的关系。
继承关系，聚合关系，关联关系。。。
类的堆砌。
类和对象
类对象
人类Person钟南山院士，你，我，王二狗，李小花，袁隆平爷爷，马云爸爸。。
狗类幻影，忠犬八公，二哈，啸天
猫类嘟嘟，卡卡，你家的猫，姥姥家的白猫
汽车类我的黑色的长城车，58台红旗车，撞我的那台车。。
笔记本电脑类我现在用的这个电脑15寸的pro，王二狗的华硕，你媳妇的联想
手机类我的华为Mate30，你的小米mix2s，你媳妇用诺基亚n95
类：其实指的就是类别。对同一类事物的统称。对这类事物进行描述，--->创建class
就是一个抽象的概念。
对象：
类中的一个具体的实例，客观存在的，能用。个体。
如何定义一个类？
要有能够描述这一类别的外部特征——我们叫做属性(静态属性)
变量就可以。(名词)
要有能够描述这一类别的行为功能——我们叫做方法(动态属性)
方法就可以。(动词)
Java中定义类的格式
/*
class ClassName{//类名首字母大写
//属性描述：外部特征
//行为描述：能够干啥
}
*/
要求：
1、CLassName要求符合驼峰命名法，首字母大写，见名知意。
2、属性描述：外部特征，用于描述这个类别的一些特征，而这些特征通过一个"词"来描述清楚，比如姓名，年龄。使用变量来表示。——【成员变量】Field，词义"字段"
3、行为描述：能够干啥，用于描述这个类别的一些行为功能，而这些行为功能，是一个动作行为，比如吃饭，睡觉。使用方法来表示。——【成员方法】Method，词义"方法"
不要加static。
方法：就是一段具有独立功能的代码。
2.4.1 step1声明类
publicclassPerson{//类的名字
}
2.4.2 step2声明类中的【成员变量】
publicclassPerson{
//step2：成员变量
Stringname;//使用String类型的变量name，表示人类中的姓名
intage;//使用int类型的变量age，表示人类中的年龄
charsex;//使用char类型的变量sex，表示人类中的性别
}
2.4.3 step3声明类中的【成员方法】
publicclassPerson{
//step2：成员变量
Stringname;//使用String类型的变量name，表示人类中的姓名
intage;//使用int类型的变量age，表示人类中的年龄
charsex;//使用char类型的变量sex，表示人类中的性别
//step3：成员方法
publicvoideat(){
System.out.println("吃饭啦。。");
}
publicvoidsleep(){
System.out.println("睡觉啦。。");
}
publicvoiddaDouDou(){
System.out.println("打豆豆。。。");
}
}
类的对象
创建类的对象
创建对象，也叫做类的实例化。对象，也叫类的实例。
/*
new关键字
new，词义：新的，新建
new 关键字，专门用于新建对象。
*/
Scannersc=newScanner();//Scanner也是个类，Person也是个类。
int[]arr=newint[5];
语法结构：
/*
类名 对象名 = new 类名();
*/
step1：创建类
step2：根据类，实例化对象
2.5.2通过对象访问属性
/*
int[] arr = new int[5];
获取数组的长度：
arr.length
arr的长度
*/
对象访问属性的语法：就是一个.
//给对象的属性，进行赋值
p1.name="王二狗";//给p1这个对象的name属性进行赋值
p1.age=18;
p1.sex='男';
//获取对象的属性值
System.out.println("姓名："+p1.name);
System.out.println("年龄："+p1.age);
System.out.println("性别："+p1.sex);
2.5.3通过对象访问方法
/*
Scanner sc = new Scanner();
sc.nextInt();
*/
Scanner，就是一个class，一个类
sc，是根据Scanner创建出来的一个对象
对象调用类中的方法，语法，也是.
对象.方法名();
p1.eat();
p1.sleep();
p1.daDouDou();
方法：public void test1();
对象.test1();
三天前的方法：public static void test1();
test1();
内存分析
实例代码：
packagecom.qf.demo01;
publicclassTest1Person{
publicstaticvoidmain(String[]args) {
//step1：创建Person类的对象
//语法：类名 对象名 = new 类名();
Personp1=newPerson();
System.out.println(p1);//打印p1的值，p1是引用类型，打印都是p1指向的对象的地址。
System.out.println(p1.name);
System.out.println(p1.age);
System.out.println(p1.sex);
/*
* com.qf.demo01.Person@15db9742
* 包名.类名@编码值 ---->理解为p1的内存地址。
*
* java中的数据类型：
* 基本类型：byte，short，char，int，long，bolean，float，double
* 引用类型：
* 数组，类类类型
*
*/
//step2：通过对象访问属性，语法是.
//给对象的属性，进行赋值
p1.name="王二狗";//给p1这个对象的name属性进行赋值
p1.age=18;
p1.sex='男';
//获取对象的属性值
System.out.println("姓名："+p1.name);
System.out.println("年龄："+p1.age);
System.out.println("性别："+p1.sex);
//step3：通过对象，访问成员方法--->理解为就是对象调用成员方法
p1.eat();
p1.sleep();
p1.daDouDou();
}
}
内存分析图
示例代码：
packagecom.qf.demo01;
publicclassTest2Person{
publicstaticvoidmain(String[]args) {
//1.创建一个Person类的对象
Personp1=newPerson();
System.out.println(p1);//p1的内存地址：com.qf.demo01.Person@15db9742
p1.name="张三狗";
p1.age=19;
p1.sex='男';
System.out.println(p1.name);//张三狗
System.out.println(p1.age);//19
System.out.println(p1.sex);//男
//2.再创建一个Person类的对象
Personp2=newPerson();
System.out.println(p2);//p2的内存地址，com.qf.demo01.Person@6d06d69c
p2.name="李小花";
p2.age=17;
p2.sex='女';
System.out.println(p2.name);//李小花
System.out.println(p2.age);//17
System.out.println(p2.sex);//女
//3.
Personp3=null;//仅仅声明了Person类型的对象p3，但是实际上，并没有在堆内存中，创建出真正的对象。
/*
* NullPointerException，空指针异常
*
* 对象不存在，就是个null，
* 强行的访问对象的属性或调用方法，就会空指针异常。
*/
//System.out.println("---->"+p3.name);//报错啦：NullPointerException
p3=p1;//将p1的值（p1对象的内存地址），赋值给p3，结果-->p1和p3存储的是同一个对象的内存地址。
p3.name="李铁柱";
System.out.println(p1.name);//李铁柱
System.out.println(p2.name);//李小花
System.out.println(p3.name);//李铁柱
Personp4=newPerson();
System.out.println(p4);//?
p4.name="王二丫";
p4.age=18;
p4.sex='女';
System.out.println(p4.name);
System.out.println(p4.age);
System.out.println(p4.sex);
p4=p1;//改变对象的内存地址了，就不再指向原来的内存对象。
System.out.println(p1.name);
System.out.println(p3.name);
System.out.println(p4.name);
}
}
内存分析图：
三、总结
1、面向对象：一种编程思想。
2、面向对象的两大核心概念：类和对象
3、类？
概念：同一类事物的统称。类别，下个定义。
描述一个类：
静态属性：成员变量：这个类别有哪些外部特征。(名词)
动态属性：成员方法：这个类别有哪些行为功能。（动词）
4、对象？
就是类中的一个具体的实例。
将类进行实例化--->得到了对象
将对象的共同特征进行抽取，加以描述--->对应的就是类。
5、语法：
step1：定义一个类
/*
public class 类名{
//成员变量
//成员方法：不加static
}
*/
publicclassPerson{
//成员变量
Stringname;
intage;
charsex;
//成员方法
publicvoideat(){}
publicvoidsleep(){}
}
step2：根据类，创建对象。（将类进行实例化，得到对象）
/*
类名 对象名 = new 类名();
*/
publicstaticvoidmain(){
Personp1=newPerson();
}
step3：对象访问类中的属性和方法
/*
.用来表示访问
对象.属性
对象.方法();
*/
publicstaticvoidmain(){
Personp1=newPerson();
p1.name="王二狗";//赋值
System.out.println(p1.name);//取值
p1.eat();//对象访问方法，将这个方法调用执行。
}
6、内存分析：
对象创建：
Personp1=newPerson();
//=左边，对象的声明，开辟栈内存
//=右边，有new，开辟堆内存，创建对象，将对象的内存地址，给p1
//结论：p1是Person类型的对象，属于引用类型，存储的都是对象的内存地址。
