目录
一、面向对象和面向过程的区别
（1）面向过程：当事件比较简单的时候，利用面向过程，注重的是事件的具体的步骤/过程，注重的是过程中的具体的行为，以函数为最小单位，考虑怎么做。
（2）面向对象：注重找“参与者”,将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
二、类和对象的关系
（1）对象：具体的事物，具体的实体，具体的实例，模板下具体的产品
（2）类：对对象向上抽取出像的部分，公共的部分，形成类，类是抽象的，是一个模板
三、面向对象的三个阶段
（1）面向对象分析OOA -- Object Oriented Analysis
对象：张三，王五，朱六，你，我
抽取出一个类----》人类
类里面有什么：
动词--》动态特性--》方法
名词--》静态特性--》属性
（2）面向对象设计OOD -- Object Oriented Design
先有类，再有对象：
类：人类： Person
对象：zhangsan ，lisi，zhuliu
（3）面向对象编程OOP -- Object Oriented Programming
四、创建类
package com.dss;
/**
* @Auther: msb-DSS
* 创建类：人类
*/
public class Person {
//名词---》属性---》成员变量---》放在类中方法外（注意：我们只把有需要的内容写到代码里，不相关的东西不要放在代码中）
int age ;//年龄
String name;//姓名
double height;//身高
double weight;//体重
//动词---》方法
//吃饭
public void eat(){
int num = 10;//局部变量：放在方法中
System.out.println("我喜欢吃饭");
}
//睡觉：
public void sleep(String address){
System.out.println("我在"+address+"睡觉");
}
//自我介绍：
public String introduce(){
return "我的名字是："+name+"，我的年龄是："+age+",我的身高是："+height+",我的体重是："+weight;
}
}
五、创建对象
package com.dss;
/**
* @Auther: msb-DSS
*/
public class Test {//测试类
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//创建一个人类的具体的对象/实例：
//创建一个对象，对象的名字叫：zs
//Person 属于 引用数据类型
//第一次加载类的时候，会进行类的加载，初始化创建对象的时候，对象的属性没有给赋值，有默认的初始化的值。
Person zs = new Person();
zs.name = "张三";
zs.age = 19;
zs.height = 180.4;
zs.weight = 170.4;
//再创建一个对象：
//再次创建类的时候，就不会进行类的加载了，类的加载只在第一次需要的时候加载一次
Person ls = new Person();
ls.name = "李四";
ls.age = 18;
ls.height = 170.6;
ls.weight = 160.5;
//对属性值进行读取：
System.out.println(zs.name);
System.out.println(ls.age);
//对方法进行操作：
//不同的对象，属性有自己的特有的值，但是方法都是调用类中通用的方法。
//属性：各个对象的属性是独立的，
//方法：各个对象的方法是共享的。
zs.eat();
ls.eat();
zs.sleep("教室");
/*String str = zs.introduce();
System.out.println(str);*/
System.out.println(zs.introduce());
}
}
六、局部变量和成员变量的区别
区别1：代码中位置不同
成员变量：类中方法外定义的变量
局部变量：方法中定义的变量 代码块中定义的变量
区别2：代码的作用范围
成员变量：当前类的很多方法
局部变量：当前一个方法（当前代码块）
区别3：是否有默认值
成员变量：有
局部变量：没有
引用数据类型： null
区别4：是否要初始化
成员变量：不需要，不建议初始化，后续使用的时候再赋值即可
局部变量：一定需要，不然直接使用的时候报错
区别5：内存中位置不同
成员变量：堆内存
局部变量：栈内存
区别6：作用时间不同
成员变量：当前对象从创建到销毁
局部变量：当前方法从开始执行到执行完毕
七、构造器
package com.dss2;
/**
* @Auther: DSS
*/
public class Person {
//构造器：没有任何参数的构造器我们叫做：空参构造器--》空构造器
public Person(){
/*age = 19;
name = "lili";
height = 169.5;*/
}
//属性：
String name;
int age;
double height;
//方法：
public void eat(){
System.out.println("我喜欢吃饭");
}
}package com.dss2;
/**
* @Auther: DSS
*/
public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//创建一个Person类的具体的对象/实例/实体：
/*
创建对象的过程：
1.第一次遇到Person的时候，进行类的加载（只加载一次）
2.创建对象，为这个对象在堆中开辟空间
3.为对象进行属性的初始化动作
new关键字实际上是在调用一个方法，这个方法叫构造方法（构造器）
调用构造器的时候，如果你的类中没有写构造器，那么系统会默认给你分配一个构造器，只是我们看不到罢了。
可以自己显式 的将构造器编写出来：
构造器的格式：
[修饰符] 构造器的名字(){
}
构造器和方法的区别：
1.没有方法的返回值类型
2.方法体内部不能有return语句
3.构造器的名字很特殊，必须跟类名一样
构造器的作用：不是为了创建对象，因为在调用构造器之前，这个对象就已经创建好了，并且属性有默认的初始化的值。
调用构造器的目的是给属性进行赋值操作的。
注意：我们一般不会在空构造器中进行初始化操作，因为那样的话每个对象的属性就一样了。
实际上，我们只要保证空构造器的存在就可以了，里面的东西不用写
*/
Person p = new Person();
System.out.println(p.age);
System.out.println(p.name);
System.out.println(p.height);
Person p2 = new Person();
System.out.println(p2.age);
System.out.println(p2.name);
System.out.println(p2.height);
}
}
八、构造器的重载
//空构造器
public Person(){
}
public Person(String name,int age,double height){
//当形参名字和属性名字重名的时候，会出现就近原则：
//在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
this.name = name;
this.age = age;
this.height = height;
}public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
/*
1.一般保证空构造器的存在，空构造器中一般不会进行属性的赋值操作
2.一般我们会重载构造器，在重载的构造器中进行属性赋值操作
3.在重载构造器以后，假如空构造器忘写了，系统也不会给你分配默认的空构造器了，那么你要调用的话就会出错了。
4. 当形参名字和属性名字重名的时候，会出现就近原则：
在要表示对象的属性前加上this.来修饰 ，因为this代表的就是你创建的那个对象
*/
Person p = new Person();
/*p.age = 19;
p.name = "lili";
p.height = 180.4;*/
Person p2 = new Person("lili",19,180.4);
System.out.println(p2.age);
System.out.println(p2.height);
System.out.println(p2.name);
}
}九、内存分析
1.java面向对象内存分析
参考：
Java面向对象内存分析_java 对象内存分析-CSDN博客
评论区：
对象里面只有属性，没方法，方法在存在堆中的方法区中，当调用方法时，首先根据引用地址找到对象，再根据对象头找到方法区中的元数据，这种是直接指针访问；或者是引用地址不指向对象，而是指向句柄池，通过句柄池访问，句柄池内存储两个信息，一个是对象的地址，一个是对象元数据的地址，这种是句柄访问。
2.this
【1】创建对象的过程：
（1）在第一次遇到一个类的时候，对这个类要进行加载，只加载一次。
（2）创建对象，在堆中开辟空间
（3）对对象进行初始化操作，属性赋值都是默认的初始值。
（4）new关键字调用构造器，执行构造方法，在构造器中对属性重新进行赋值
this关键字 用：
（a）this可以修饰属性：
总结：当属性名字和形参发生重名的时候，或者 属性名字 和局部变量重名的时候，都会发生就近原则，所以如果我要是直接使用变量名字的话就指的是离的近的那个形参或者局部变量，这时候如果我想要表示属性的话，在前面要加上：this.修饰
如果不发生重名问题的话，实际上你要是访问属性也可以省略this.
（b）this修饰方法：
总结：在同一个类中，方法可以互相调用，this.可以省略不写。
（c）this可以修饰构造器：
总结：同一个类中的构造器可以相互用this调用，注意：this修饰构造器必须放在第一行
3.static
static修饰属性总结：
（1）在类加载的时候一起加载入方法区中的静态域中
（2）先于对象存在
（3）访问方式： 对象名.属性名 类名.属性名（推荐）
static修饰属性的应用场景：某些特定的数据想要在内存中共享，只有一块 --》这个情况下，就可以用static修饰的属性
4.代码块
代码块执行顺序：
最先执行静态块，只在类加载的时候执行一次，所以一般以后实战写项目：创建工厂，数据库的初始化信息都放入静态块。
一般用于执行一些全局性的初始化操作。
再执行构造块，（不常用）
再执行构造器，
再执行方法中的普通块。
十、三大特性
1.封装
（a）java中封装的概念
将某些东西进行隐藏，然后提供相应的方式进行获取
我们程序设计追求“高内聚，低耦合”。
➢高内聚:类的内部数据操作细节自己完成，不允许外部干涉;
➢低耦合:仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提
高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露
的暴露出来。这就是封装性的设计思想。
（b）封装的好处：
提高了代码的安全性
private int age;
上面的代码，对于属性age来说，我加了修饰符private，这样外界对它的访问就受到了限制，现在我还想加上其他的限制条件，但是在属性本身上没有办法再加了，所以我们通过定义方法来进行限制条件的添加。
以属性为案例：
进行封装：
（1）将属性私有化，被private修饰--》加入权限修饰符
一旦加入了权限修饰符，其他人就不可以随意的获取这个属性
（2）提供public修饰的方法让别人来访问/使用
（3）即使外界可以通过方法来访问属性了，但是也不能随意访问，因为咱们在方法中可以加入 限制条件。
2.继承
（a）继承关系 ：
父类/基类/超类
子类/派生类
子类继承父类一定在合理的范围进行继承的 子类 extends 父类
（b）继承的好处：
①提高了代码的复用性，父类定义的内容，子类可以直接拿过来用就可以了，不用代码上反复重复定义了
②便于代码的扩展
③为了以后多态的使用。是多态的前提。
（c）父类private修饰的内容，子类也继承过来了。
（d）一个父类可以有多个子类。
（e）一个子类只能有一个直接父类。
但是可以间接的继承自其它类。
（f）继承具有传递性：
Student --》继承自 Person ---》继承自Object
Object类是所有类的根基父类。
所有的类都直接或者间接的继承自Object。
（1）.权限修饰符
（2）.重写
【1】重写：
发生在子类和父类中，当子类对父类提供的方法不满意的时候，要对父类的方法进行重写。
【2】重写有严格的格式要求：
子类的方法名字和父类必须一致，参数列表（个数，类型，顺序）也要和父类一致。
3.多态
（1）先有父类，再有子类：--》继承 先有子类，再抽取父类 ----》泛化
（2）什么是多态：
多态就是多种状态：同一个行为，不同的子类表现出来不同的形态。
多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为。
（3）多态的好处：
为了提高代码的扩展性，符合面向对象的设计原则：开闭原则。
开闭原则：指的就是扩展是 开放的，修改是关闭的。
注意：多态可以提高扩展性，但是扩展性没有达到最好，以后我们会学习 反射
（4）多态的要素：
一，继承： Cat extends Animal ,Pig extends Animal, Dog extends Animal
二，重写：子类对父类的方法shout()重写
三， 父类引用指向子类对象：
957
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
