1.面向过程和面向对象的区别
【1】面向过程：当时间比较简单的时候，利用面向过程，注重的是事件的具体的步骤/过程，注重的是过程中具体的行为，以函数为具体的单位。（怎么做)
【2】面向对象：注重找“参与者”，将其功能封装进对象，强调了具备功能的对象，以类或对象为最小单位。（谁来做）
eg：
用洗衣机洗衣服
函数1：打开洗衣机（）{人站在洗衣机前，打开洗衣机门，衣服放进去.......}
函数2：开始洗衣服（）{倒入洗衣液，按好开关，洗衣机开始运转......}
函数3：关闭洗衣机（）{人站在洗衣机前，打开洗衣机门，衣服拿出来......}
面向对象：
人{
打开（洗衣机）{
? ? ? ? 洗衣机.打开（）;
?}
存储（衣服）{
? ? ? ? 衣服.进入（）；
}
关闭（洗衣机）{
? ? ? ? 洗衣机.关闭（）；
}
}
洗衣机{
打开（）{}
关闭（）{}
}
衣服{
? 进入（洗衣机）{}
}
}
面向过程 ------>面向对象，其实就是由执行者------>指挥者的 一个过渡
（二者相辅相成，并不是对立的。解决复杂问题，通过面向对象方式便于我们从宏观上把握事物之间复杂的关系，方便我们分析整个系统：具体到微观操作，仍然使用面向过程方式来处理）
（面向对象三大优点：封装，继承，多态）
2.类和对象
【1】类：对对象向上抽取出像的部分，公共的部分，形成类，类是抽象的，是一个模板
【2】对象：具体的事物，具体的实体，具体的实例，模板下具体的产品
【3】写代码的时候，一般都是先写类，然后再根据类创建对应的对象。
3.面向对象的三个阶段：
【1】面向对象分析OOA? ------>Object Oriented Analysis
eg：对象（你，我，他）
抽取出一个类 -----> 人类
类里面有什么：
动词 ---> 动态特性 ---> 方法
名词 ---> 静态特性 ---> 属性
【2】面向对象设计OOD? ------->Object Oriented Design
eg：
（先有类，再有对象）
类：人类：Person
对象：you , I , he
【3】面向对象编程OOP? ------->Object Oriented Programming
4.创建
【1】创建类
（1）属性（field 成员变量）
属性用于定义该类或该类成员变量包含的数据或者说静态特征。属性作用范围是整个类体。
属性定义格式：
[修饰符] 属性类型 属性名 = [默认值] ；
（2）方法
方法用于定义该类或该类的行为特征和功能实现。方法是类和对象行为特征的抽象，方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法从属于类和对象。
方法定义格式：
[修饰符] 方法返回值类型 方法名 （形参列表）{
? ? ? ?//n条语句
}
void代表没有返回值；方法的作用：重用代码，封装功能，便于修改
代码：
package Wangmain;
/**
* @Auther:雨天.
* @Date:2021/12/8 - 12 - 08 - 22:04
* @Description:Wangmain
* @version:1.0
*/
public class Person {
//名词 ----> 属性 ----->成员变量 ---->放在类中方法外（注意：只把有相关的写在代码中，不相关的不用写）
int age;//年龄
String name;//姓名
double height;//身高
double weight;//体重
//动词 ----> 方法
public void eat(){
int num = 11;//局部变量：放在方法中
System.out.println("我喜欢吃肉");
}
public void sleep(String address){
System.out.println("我喜欢在"+address+"睡觉");
}
//自我介绍、
public String introduce(){
return"我的名字是："+name+",我的年龄是："+age+",我的身高是"+height+",我的体重是："+weight+;
}
}【2】创建对象
代码：
package Wangmain;
/**
* @Auther:雨天.
* @Date:2021/12/8 - 12 - 08 - 23:07
* @Description:Wangmain
* @version:1.0
*/
public class Test {
public static void main(String[] args) {
//创建一个人类具体的对象/实例
//创建一个对象，对象的名字叫yd
//Person 属于引用数据类型
//第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化值
Person yd = new Person();
yd.name = "一迪";
yd.weight = 55;
yd.height = 174;
yd.age = 19;
//创建一个新对象
Person dd = new Person();
dd.name = "荻荻";
dd.age = 19;
dd.height = 175;
dd.weight = 65;
//对属性值进行读取
System.out.println(yd.name);
System.out.println(dd.height);
//对方法进行操作
//不同的对象，属性有自己特有的值，方法都是调用类中通用的方法
//属性：各个对象的属性是独立的
//方法：各个对象的方法是共享的
yd.eat();
dd.eat();
yd.sleep("家里");
String str = yd.introduce();
System.out.println(str);
}
}5.局部变量和成员变量的区别
【1】区别1：代码中位置不同
? ? ? ? ? ? ? ? 成员变量：类中方法外定义的变量
? ? ? ? ? ? ? ? 局部变量：方法中定义的变量? ?代码块中定义的变量
【2】区别2：代码的作用范围
? ? ? ? ? ? ? ? 成员变量：当前类的很多方法
? ? ? ? ? ? ? ? 局部变量：当前一个方法（当前代码块）
【3】区别3：是否有默认值
? ? ? ? ? ? ? ? 成员变量：有
? ? ? ? ? ? ? ? 局部变量：没有
【4】区别4：是否要初始化
? ? ? ? ? ? ? ? 成员变量：不需要，不建议初始化，需要赋值赋值即可
? ? ? ? ? ? ? ? 局部变量：一定需要，不赋值就报错
【5】区别5：内存中位置不同
? ? ? ? ? ? ? ? 成员变量：堆内存
? ? ? ? ? ? ? ? 局部变量：?栈内存
【6】区别6：作用时间不同
? ? ? ? ? ? ? ? 成员变量：当前对象从创建到销毁
? ? ? ? ? ? ? ? 局部变量：当前方法从开始执行到执行完毕
（代码）
package Wangmain;
/**
* @Auther:雨天.
* @Date:2021/12/9 - 12 - 09 - 0:12
* @Description:Wangmain
* @version:1.0
*/
public class Student {
byte e;
short f;
int d;//成员变量
long g;
float x;
double y;
char ch;
boolean bo;
String name;
public void study() {
int num = 1;//局部变量，在方法中
System.out.println(num);//10 局部变量一定要进行初始化值
//int num;重复命名，出错
{
int b;//局部变量，在代码块中
}
if(1==2){
int c;
}
System.out.println(d);
}
public void eat(){
System.out.println(d);
}
//这是一个main方法，程序的入口
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.d);
System.out.println(s.x);
System.out.println(s.e);
System.out.println(s.g);
System.out.println(s.bo);
System.out.println(s.ch);
System.out.println(s.y);
System.out.println(s.f);
System.out.println(s.name);
}
}??运行结果：
?
5.构造器
【1】构造器的格式：
[修饰符] 构造器的名字 （）{
}?
【2】构造器和方法的区别：
（1）没有方法的返回值类型
（2）方法体内部不能有return语句
（3）构造器名字特殊，和类名一样
【3】构造器的作用：
不是为了创建对象，调用构造器之前，对象已经创建好了，属性有默认的初始化值
【4】调用构造器目的：为属性进行赋值操作
（注意：一般不会在构造器中进行初始化操作，那样每个对象的属性就一样了）
（代码插入）
?
package Wangmain02;
/**
* @Auther:雨天.
* @Date:2021/12/9 - 12 - 09 - 12:31
* @Description:Wangmain02
* @version:1.0
*/
public class Person {
//构造器（显式）：没有任何参数的构造器，我们叫做空参构造器----->空构造器
public Person(){
age = 19;
name = "张三";
height = 174;
}
//属性
String name;
int age;
double height;
//方法
public void sleep(){
System.out.println("我喜欢睡觉");
}
}
??
package Wangmain02;
/**
* @Auther:雨天.
* @Date:2021/12/9 - 12 - 09 - 15:42
* @Description:Wangmain02
* @version:1.0
*/
public class Test {
public static void main(String[] args) {
//创建一个Person类的具体的对象/实例/实体
/*
创建对象的过程：
1.第一次遇到Person的时候，进行类的加载（只加载一次）
2.创建对象，为这个对象在堆中开辟空间
3.为对象进行属性的初始化动作
new 关键字实际上就是在调用一个方法，这个方法叫做构造方法（构造器）
调用构造器的时候，如果类中没有写构造器，那么系统会默认分配构造器
可手动显式将构造器编写出来
构造器的格式：
[修饰符] 构造器的名字（）{
}
构造器和方法的区别：
（1）没有方法的返回值类型
（2）方法体内部不能有return语句
（3）构造器名字特殊，和类名一样
构造器的作用：不是为了创建对象，调用构造器之前，对象已经创建好了，属性有默认的初始化值
调用构造器目的：为属性进行赋值操作
注意：一般不会在构造器中进行初始化操作，那样每个对象的属性就一样了
(实际上，只要保证空构造器的存在，不用在里面写)
*/
Person p = new Person();
System.out.println(p.name);
System.out.println(p.age);
System.out.println(p.height);
Person p2 = new Person();
System.out.println(p2.age);
System.out.println(p2.name);
System.out.println(p2.height);
}
}
?
?构造器的重载：
package Wangmain03;
/**
* @Auther:雨天.
* @Date:2021/12/9 - 12 - 09 - 16:48
* @Description:Wangmain03
* @version:1.0
*/
public class Person {
public Person(){
}
//构造器的重载：方法名相同，形参列表不同
public Person(String name,int age,double height){
//当形参和属性名字重名的时候，会出现就近原则
//再要表示对象的属性前加上this. 修饰，因为 this. 代表的就是创建的对象
this.name = name;
this.age = age;
this.height = height;
}
public Person(String a,int b){
}
//属性
String name;
int age;
double height;
//方法
public void sleep() {
System.out.println("我喜欢睡觉");
}
}
package Wangmain03;
/**
* @Auther:雨天.
* @Date:2021/12/9 - 12 - 09 - 16:51
* @Description:Wangmain03
* @version:1.0
*/
public class Test {
public static void main(String[] args) {
/*
1.一般保证空构造器的存在，空构造器中一般不会进行赋值操作
2.一般会重载构造器，在重载的构造器中进行赋值操作
3.重载构造器后，假如空构造器忘写了，系统不会分配默认的空构造器，会出错
*/
Person p = new Person();
Person p1 = new Person("张三",30,160.3);
System.out.println(p1.height);
System.out.println(p1.age);
System.out.println(p1.name);
}
}