面向过程： 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了 面向对象： 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为 总结
都是解决问题的思维方式，都是代码的组织方式 解决简单问题可以使用面向过程 解决复杂问题，宏观上使用面向对象把握，微观处理上仍然使用面向过程处理 封装：需要让用户知道的暴露出来，不需要用户知道的隐藏起来，这就是封装–“该露的露，该藏的藏” 继承：一方面，继承的本质是对某一批类的抽象，从而实现对现实世界更好的封装。另一方面，代码的重用 多态：为了提高处理问题的灵活性，原始的抽象的事务，可以出现多种不同的形态展现 类: 类是一组相关属性和行为的集合，
可以看成是一类事物的模板，
使用事务特征和行为特征来描述该类事物
现实中，描述一类事物
属性：就是事物的状态信息
行为：就是事物的功能
对象：对象是一类事物的具体体现，对象是类的一个实例，
必然具备该事物的属性和行为
现实中,一类事物的一个实例，就是一个对象
关系：
1、类可以看做是一个模板，或者图纸，
系统根据类的定义来创造出对象
2、类是对一类事物的描述，是抽象的
3、对象是一类事物的实例，是具体的
类是现实世界的一类事物
属性：事物的状态信息
行为：事物的功能和作用
Java中用Class描述事物也是如此
成员变量：对应事物的属性
成员方法：对应事物的行为
定义类：
就是定义类的成员，包括成员属性和成员方法
成员变量的位置：
定义在类中，方法外
成员方法的位置：
定义在类中，与之前的方法不一致的是，去掉了static
public class 类的名称{
}
public class Student {
String name;
int age;
String address;
public void study ( ) {
System . out. println ( "好好学习" ) ;
}
public void paly ( ) {
System . out. println ( "多运动多锻炼" ) ;
}
public void sleep ( ) {
System . out. println ( "中午午休" ) ;
}
}
一般情况下，一个类并不能直接使用，需要根据类创建一个对象才能使用
创建对象的步骤：
- 1 、导包：指出使用的类存放的位置, 如果在同包中，导包省略
- 2 、创建：类名称 对象名 = new 类名称( ) ;
- 3 、使用：两种情况
- 使用成员变量：对象名. 成员变量;
- 使用成员方法：对象名. 成员方法( ) ;
注意事项
- 如果成员变量没有赋值，那么就会出现默认值
- 整数类型的默认值是0 ，引用数据类型的默认值是null
* *
* 对象的使用：
* 一般情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用
* 创建对象步骤：
* 1 、导包：指出使用的类存放的位置, 如果在同包中，导包省略
* 2 、创建：类名称 对象名 = new 类名称( ) ;
* 3 、使用：两种情况
* 使用成员变量：对象名. 成员变量;
* 使用成员方法：对象名. 成员方法( ) ;
* 注意事项：如果成员变量没有赋值，那么就会出现默认值，
* 整数类型的默认值是0 ，引用数据类型的默认值是null
* /
public class StudentTest {
public static void main ( String [ ] args) {
Student stu1 = new Student ( ) ;
System . out. println ( stu1. name) ;
System . out. println ( stu1. age) ;
System . out. println ( stu1. address) ;
System . out. println ( "------------------------" ) ;
stu1. name= "Tom" ;
stu1. age= 33 ;
stu1. address= "北京" ;
System . out. println ( stu1. name) ;
System . out. println ( stu1. age) ;
System . out. println ( stu1. address) ;
stu1. study ( ) ;
stu1. paly ( ) ;
stu1. sleep ( ) ;
}
}
public class Computer {
String brand;
double price;
String color;
public void playGame ( ) {
System . out. println ( "电脑可以打游戏！" ) ;
}
public void lookMovie ( ) {
System . out. println ( "电脑可以看电影！" ) ;
}
public void chart ( ) {
System . out. println ( "电脑可以聊天！" ) ;
}
}
public class ComputerTest {
public static void main ( String [ ] args) {
Computer computer = new Computer ( ) ;
System . out. println ( computer. brand) ;
System . out. println ( computer. price) ;
System . out. println ( computer. color) ;
computer. brand = "华为" ;
computer. price = 5000.0 ;
computer. color = "pink" ;
System . out. println ( computer. brand) ;
System . out. println ( computer. price) ;
System . out. println ( computer. color) ;
computer. playGame ( ) ;
computer. lookMovie ( ) ;
computer. chart ( ) ;
}
}
- 对象内存图理解：
- 1 、先加载Computer 类信息`：属性与方法
- 2 、进行默认初始化，再显示初始化（double price = 5000.0 ）
最后执行构造方法初始化`
- 3 、把堆中的地址赋给computer，computer就指向对象，
computer是对象的引用`，或者叫对象名
- 4 、当执行到方法时，就会开辟独立的空间（栈）`
- 5 、方法执行完毕/ 执行到return 就会返回到调用方法的地方`
- 6 、继续执行后续代码
- 7 、当main方法（栈）`执行完毕，程序退出
- 1、定义的位置不一样
- 局部变量：定义在方法的内部
- 成员变量：定义在类的内部，方法的外部
- 2、作用域不一样
- 局部变量：只有在方法中才能使用，出了方法不能使用
- 成员变量：在整个类中通用
- 3、默认值不一样
- 局部变量：没有默认值，必须手动赋值
- 成员变量：默认会有初始值
- 4、内存的位置不一样
- 局部变量：存储在栈内存
- 成员变量：存储在堆内存
- 5、生命周期不一样
- 局部变量：随着方法的进栈而诞生，随着方法的出栈而消失
- 成员变量：随着对象被创建而诞生，随着对象被垃圾回收器回收被销毁
public class VariableDemo01 {
String username;
public void sleep ( ) {
int num;
int num1 = 20 ;
System . out. println ( num1) ;
System . out. println ( username) ;
}
public void eat ( int num2) {
System . out. println ( num2) ;
}
}
封装就是把属于同一类事物的共性放到一个类中，
将不需要对外提供的内容都隐藏起来、
把属性都隐藏，提供公共方法对其访问。
将变化隔离、便于使用、提高重用性、提高安全性
将不需要对外提供的内容都隐藏起来、
把属性都隐藏，提供公共方法对其访问
private关键字：
1、private是用于对需要保护的成员变量进行修饰。
2、一旦使用private关键字，在本类当中仍可以随意访问，
但是在本类之外就不能访问。
3、如果想访问private关键字修饰的成员变量，
就需要定义一对setter/和getter方法
注意事项：
- 方法名：必须使用setXxx或者getXxx命名规则
- 对于getter来说，不能有参数，返回值类型和成员变量对应
- 对于setter来说，不能有返回值，参数类型和成员变量对应
- 对于基本数据类型的boolean型，setter方法同上，
但是获取的方法是使用isXxx()
public class Person {
String name;
private int age;
public void info ( ) {
System . out. println ( name+ ":" + age) ;
}
public void setAge ( int age) {
if ( 0 <= age && age>= 100 ) {
this . age = age;
} else {
System . out. println ( "输入的年龄错误" ) ;
}
}
public int getAge ( ) {
return age;
}
}
public class Demo01_Private {
public static void main ( String [ ] args) {
Person p = new Person ( ) ;
p. name = "张曼玉" ;
p. setAge ( - 22 ) ;
System . out. println ( p. getAge ( ) ) ;
}
- 1、当方法的局部变量和类的成员变量名称相同时，
就遵循就近原则，优先使用局部变量
- 2、如果必须使用成员变量，则需要使用this关键字，
即：this.成员变量
- 3、this关键字：指向调用方法的对象，
即通过谁调用的方法，this就是谁
public class Student {
String name;
public void sayName1 ( String str) {
System . out. println ( name + "---" + str) ;
}
public void sayName2 ( String name) {
System . out. println ( name+ "===" + name) ;
}
public void sayName3 ( String name) {
System . out. println ( this . name+ "+++" + name) ;
System . out. println ( this ) ;
}
}
public class Demo01_This {
public static void main ( String [ ] args) {
Student s1 = new Student ( ) ;
s1. name = "巩俐" ;
s1. sayName1 ( "章子怡" ) ;
s1. sayName2 ( "关之琳" ) ;
s1. sayName3 ( "邱淑贞" ) ;
System . out. println ( s1) ;
}
}
1、是用来专门创建对象的方法
2、当我们通过关键字new来创建对象时，
其实就是在调用构造方法
public 类名称( ) {
}
public 类名称( 参数类型 参数名, 参数类型 参数名) {
方法体;
}
1、构造方法的名称必须和类的名称一致，包含大小写一致
2、构造方法不需要写返回值类型，包括void
3、构造方法没有返回值
4、如果没有声明任何构造方法，
编译器会默认提供一个无参数的构造方法供使用
5、一旦编写任意构造方法，编译器将不提供无参构造方法
6、如果已经创建有参构造，那么无参构造默认不存在，
需要手动定义无参构造
public class User {
private String name;
private int age;
public User ( ) {
System . out. println ( "无参构造方法执行了" ) ;
}
public User ( String name, int age) {
this . name = name;
this . age = age;
System . out. println ( "有参构造方法执行了" ) ;
}
public String getName ( ) {
return name;
}
public void setName ( String name) {
this . name = name;
}
public int getAge ( ) {
return age;
}
public void setAge ( int age) {
this . age = age;
}
}
public class Demo01_ConstructorTest {
public static void main ( String [ ] args) {
User u1 = new User ( ) ;
u1. setName ( "周海媚" ) ;
u1. setAge ( 22 ) ;
System . out. println ( u1. getName ( ) ) ;
System . out. println ( u1. getAge ( ) ) ;
System . out. println ( "--------------------" ) ;
User u2 = new User ( "邵美琪" , 22 ) ;
System . out. println ( u2. getName ( ) ) ;
System . out. println ( u2. getAge ( ) ) ;
}
}
- 1、所有的成员变量都需要使用private关键字修饰
- 2、为每一个成员变量编写一对setter和getter方法
- 3、编写一个无参数的构造方法
- 4、编写一个全参数的构造方法
- 5、这样标准的类，也叫作JavaBean(Java豆子)
public class Student {
private String username;
private int age;
private String address;
public Student ( ) {
}
public Student ( String username, int age, String address) {
this . username = username;
this . age = age;
this . address = address;
}
public String getUsername ( ) {
return username;
}
public void setUsername ( String username) {
this . username = username;
}
public int getAge ( ) {
return age;
}
public void setAge ( int age) {
this . age = age;
}
public String getAddress ( ) {
return address;
}
public void setAddress ( String address) {
this . address = address;
}
}
public class Demo01_StudentTest {
public static void main ( String [ ] args) {
Student s1 = new Student ( ) ;
s1. setUsername ( "古力娜扎" ) ;
s1. setAge ( 22 ) ;
s1. setAddress ( "新疆" ) ;
System . out. println ( "姓名是：" + s1. getUsername ( ) + "，年龄是：" + s1. getAge ( ) + "，籍贯是：" + s1. getAddress ( ) ) ;
System . out. println ( "-------------------------------" ) ;
Student s2 = new Student ( "迪丽热巴" , 18 , "新疆" ) ;
System . out. println ( "姓名是：" + s2. getUsername ( ) + "，年龄是：" + s2. getAge ( ) + "，籍贯是：" + s2. getAddress ( ) ) ;
s2. setAge ( 19 ) ;
System . out. println ( "姓名是：" + s2. getUsername ( ) + "，年龄是：" + s2. getAge ( ) + "，籍贯是：" + s2. getAddress ( ) ) ;
}
}
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bIm2zNzs-1686187958346)(photo/JavaSE06_面向对象之封装.assest/1664705217813.png)]](https://img-blog.csdnimg.cn/667ffd6b56e74bf280159db7ebb658bd.png)
