- 一、面向对象与面向过程
- 二、面向对象
- 1、面向对象的特征
- 2、类和对象的概念
- 3、整个软件开发过程
- 三、类的定义
- 四、对象的创建和使用
- 1、类体
- 2、实例化对象
- 3、成员变量的默认值
- 4、引用
- 5、对象和引用
- 五、JVM内存空间
- 六、空指针异常
- 七、面向对象的封装性
- 1、封装的好处
- 2、封装的步骤
- 3、set和get的规范
- 八、练习
1、面向过程和面向对象的区别
-
面向过程：
- 主要的关注点是：实现简单的过程【集成显卡的开发思路】
- 优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低
- 缺点：采用面向过程的方式开发很难解决复杂的业务逻辑问题，此外，面向过程的方式导致软件元素之间的"耦合度"非常高，只要其中一环出现了问题，整个系统就会受到影响，导致最终的软件扩展能力差。另外，由于没有独立体的概念，所以无法达到组件复用性的功能
-
面向对象：
- 主要关注点是：关注对象【独立体】能完成哪些功能。【独立显卡的开发思路】
- 优点：耦合度低，扩展力强。更容易解决现实世界当中复杂的业务逻辑问题。组件复用性强。
- 缺点：前期投入成本较高，需要进行独立的抽取，大量的系统分析与设计。
-
C语言是纯面向过程的、C++是半面向对象的、java是纯面向对象的
-
面向对象更加符合人的思维方式
- 封装
- 继承
- 多态
- 这三大特征是所有的面向对象的编程语言都有的
采用面向对象的编程语言开发一个软件，生命周期当中：
- 面向对象的分析：OOA
- 面向对象的设计：OOD
- 面向对象的编程：OOP
- 【整个生命周期当中贯穿使用OO面向对象方式】
【1】类：
- 类描述的是对象的共同特征
- 类在现实世界当中是不存在的，是一个模板，一个概念，是人大脑抽象的结果。
- 类代表了一类具有共同特征的事物。
- 在现实世界当中，对象a与对象b之间具有共同特征，进行抽象总结出一个模板，这个模板被称为类。
【2】对象：
- 对象是在现实世界中实际存在的个体。
【3】实例化与抽象：
- 类–【实例化】–>对象
- 对象又被称为实例/instance
- 对象–【抽象】–>类
- 程序员先观察现实世界，从现实世界当中寻找对象
- 寻找了N多个对象之后，发现所有的对象都有共同的特征
- 程序员在大脑当中形成了一个模板【类】
- java程序员可以通过java代码来表述一个类
- java程序中有了类的定义
- 然后就通过类创建对象
- 有了对象之后，可以让对象直接协作起来形成一个系统
语法结构：
[修饰符列表] class 类名{
属性；
方法；
}
学生类，描述所有学生对象的共同特征：
学生类属于引用数据类型，不属于基本数据类型。
1、学生对象有哪些状态信息：
- 学号【int】
- 名字【string】
- 性别【boolean】
- 年龄【int】
- 住址【String】
2、学生对象有哪些动作信息：
- 吃饭
- 睡觉
- 学习
- 玩游戏
重点：属性通常是采用一个变量的形式来完成定义的
在这里插入代码片
引用数据类型：
String.class 【SUM提供的】 Student.class 【SUM提供的】 User.class 【程序员自定义的】 Product.class 【程序员自定义的】 Customer.class 【程序员自定义的】 ......四、对象的创建和使用 1、类体
类体=属性+方法
- 属性【存储数据采用变量的形式】
由于变量定义在类体当中，方法体之外，这种变量称为成员变量 - 所有学生都有学号信息，但是每一个学生的学号都是不同的，所以要访问这个学号必须先创建对象，通过对象去访问学号信息。学号信息不能直接通过“类”去访问，所以这种成员变量又被叫做实例变量
- 对象又被称为实例，实例变量又被称为对象变量。【对象级别的变量】
- 不创建对象，这个no变量的内存空间是不存在的，只有创建了对象，这个no变量的内存空间才会创建
实例化对象的语法：
new 类名（）；
- 通过一个类可以实例化N个对象
- new是java语言当中的一个运算符
- new运算符的作用：创建对象，在JVM堆内存当中开辟新的内存空间
- 方法区内存：在类加载的时候，class字节码代码片段被加载到该内存空间当中。
- 栈内存（局部变量）：方法代码片段执行的时候，会给该方法分配内存空间，在栈内存中压栈
- 堆内存：new的对象在堆内存中存储
public static void main(String[] args) {
//Student是一个引用数据类型
//s是一个变量名，是引用，里面存放的是对象在堆内存当中的地址
//new Student()是一个学生对象
Student s=new Student();
}
3、成员变量的默认值
| 数据类型 | 默认值 |
|---|---|
| byte，short，int，long | 0 |
| float，double | 0.0 |
| boolean | false |
| char | u0000 |
| 引用数据类型 | null（和void不同，void的返回值类型为空） |
引用：引用是一个变量，只不过这个变量当中保存了另一个java对象的内存地址
java程序员要访问堆内存当中的数据，必须通过引用
- java语言当中，程序员不能直接操作堆内存，java中没有指针
- java语言当中，程序员只能通过“引用”去访问堆内存当中的对象内部的实例变量
访问实例变量的语法格式：
读取数据：引用.变量名 修改数据：引用.变量名 = 值
public static void main(String[] args) {
//Student是一个引用数据类型
//s是一个变量名
//new Student()是一个学生对象
Student s=new Student();
int stuNo=s.no;
String stuName=s.name;
int stuAge=s.age;
boolean stuSex=s.sex;
String stuAddr=s.address;
//修改内存
s.no=10;
s.name="jack";
s.age=20;
s.sex=true;
s.address="北京";
//再通过类实例化一个全新的对象
//stu是一个引用,同时也是一个局部变量
//Student是变量的数据类型
Student stu=new Student();
}
- 局部变量在栈内存中存储，成员变量中的实例变量在堆内存的java对象内部存储
- 实例对象是一个对象1份，100个对象100份
//此时编译报错，因为no这个实例变量不能直接采用类名的方式访问
//no是实例变量，对象级别的变量，变量存储在java内部，必须先有对象
//需要通过对象才能访问no这个实例变量
System.out.println(Student.no);
//测试类
public class OOTest2 {
public static void main(String[] args) {
//创建User对象
User u=new User();
//修改User对象内部实例变量的值
u.no=100;
u.name="jack";
u.addr=new Address();
u.addr.city="北京";
u.addr.street="朝阳";
u.addr.zipcode="10001";
System.out.println(u.name+"居住在哪个城市："+u.addr.city);
}
}
5、对象和引用
- 对象：目前在使用new运算符在堆内存中开辟的内存空间称为对象
- 引用：是一个变量，不一定是局部变量，还可能是成员变量。引用保存了内存地址，指向了堆内存当中的对象。
- 所有访问实例相关的数据，都需要通过引用的方式访问，因为只有通过引用才能找到对象。
- 只有一个空的引用，访问对象的实例相关的数据会出现空指针异常
public class Student {
Computer com;//com是一个引用【实例变量】
public static void doSome(){
Computer cc;//cc是一个引用【局部变量】
}
}
五、JVM内存空间
1、JVM（JAVA虚拟机）主要包括三块内存空间，分别是：栈内存，堆内存，方法区内存
2、堆内存和方法区内存各有一个，一个线程一个栈内存
3、方法调用的时候，该方法所需要的内存空间在栈内存中分配，称为压栈。方法执行结束之后，该方法所属的内存空间释放，称为出栈。
4、栈中主要存储的是方法体当中的局部变量
5、方法的代码片段以及整个类的代码片段都被存储到方法区内存当中，在类加载的时候这些代码片段会带入
6、在程序执行过程中使用new运算创建java对象，存储在堆内存当中，对象内部有实例变量，所以实例变量存储在堆内存当中
7、变量的分类：
- 局部变量【方法体内部声明】
- 成员变量【方法体外部声明】
- 实例变量【前边修饰符没有static】
- 静态变量【前边修饰符有static】
8、静态变量存储在方法区内存当中
9、三块内存当中，最频繁的是栈内存，最先有数据的是方法区内存，垃圾回收器主要针对的是堆内存
10、垃圾回收器：
- 当堆内存当中的java对象成为垃圾数据的时候，会被垃圾回收器回收
- 什么时候堆内存中的java对象会变成垃圾呢？没有更多的引用指向它的时候，因为访问对象只能通过引用的方式实现
空引用访问实例相关的数据，一定会出现空指针异常：java.lang.NullPointerException
实例相关的数据：表示这个数据访问的时候必须有对象的参与。这种数据就是实例相关的数据。
public class OOTest2 {
public static void main(String[] args) {
//创建User对象
User u=new User();
System.out.println(u.no);
u=null;
System.out.println(u.no);
}
}
七、面向对象的封装性
1、封装的好处
- 封装之后，对于那个事物来说，只能看到该事物简单的一面。复杂性封装，对外提供简单的操作入口。例如：照相机，照相机的原理实现很复杂，但是对于使用照相机来说，操作起来非常方便。
- 封装之后才会形成真正的“对象”，真正的独立体。
- 封装之后意味着以后的程序可以重复使用，并且这个事物应该适应性较强，在任何场合都能使用。
- 封装之后，对于事物本身是安全的。
-
1、所有属性私有化，使用private关键字进行修饰，private表示私有的，修饰的所有的数据只能在本类当中访问。
-
2、对外提供简单的操作入口，也就是说，外部程序想要访问age属性，必须通过这些简单的入口进行访问
- 对外提供两个公开的方法，分别是set方法和get方法
- 想修改属性，就使用set方法
- 想读取属性，就使用get方法
-
3、一个属性通常的访问包括两种访问形式：
-
第一种方式：读取这个属性的值【get】
-
第二种方式：修改这个属性的值【set】
1、set方法的命名规范
pulic void set+属性名首字母大写（形参）{
}
public void setAge(int a){
age=a;
}
2、get方法的命名规范
pulic void get+属性名首字母大写（形参）{
}
public void getAge(){
return age;
}
注意：
- set和get方法没有static关键字
- 有static关键字修饰的方法怎么调用：类名.方法名（实参）；
- 没有static关键字修饰的方法怎么调用：引用.方法名（实参）；
public class User {
private int age;
//set方法没有返回值，因为set方法只负责修改数据
public void setAge(int a){
if(a<0||a>150){
System.out.println("输入的年龄不合法");
return ;
}
age=a;//java的就近原则
}
public int getAge(){
return age;
}
}
public class UserTest {
public static void main(String[] args) {
//创建User1对象
User1 u=new User1();
//修改
u.setAge(100);
//读取
System.out.println(u.getAge());
}
}
八、练习
需求：
定义一个计算机类【电脑/笔记本】，计算机类有哪些属性：
- 品牌
- 型号
- 颜色
定义一个学生类，学生类有哪些属性：
- 学号
- 姓名
- 学生有一台笔记本电脑
请编写程序来表示以上的类，然后分别将类创建为对象，对象的数量不限，然后让其中的一个学生去使用其中的一台笔记本电脑。
class Computer {
String label;
String type;
String color;
}
class Student {
int no;
String name;
Computer c;
}
public class Test {
public static void main(String[] args) {
Student s=new Student();
Computer c=new Computer();
c.label="ThinkPad";
c.type="big";
c.color="yellow";
s.no=123;
s.name="susie";
System.out.println(s.name+"使用"+s.c.color+"的"+s.c.type+"大小的"+s.c.label);
}
}
