JavaSE-06 [面向对象+封装]

第一章 面向对象思想

1.1 面向过程和面向对象

• 面向过程： 面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了
• 面向对象： 面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为
• 总结
  • 都是解决问题的思维方式，都是代码的组织方式
  • 解决简单问题可以使用面向过程
  • 解决复杂问题，宏观上使用面向对象把握，微观处理上仍然使用面向过程处理

面向对象编程的三大特征(抽象)

• 封装：需要让用户知道的暴露出来，不需要用户知道的隐藏起来，这就是封装–“该露的露，该藏的藏”
• 继承：一方面，继承的本质是对某一批类的抽象，从而实现对现实世界更好的封装。另一方面，代码的重用
• 多态：为了提高处理问题的灵活性，原始的抽象的事务，可以出现多种不同的形态展现

1.2 类和对象

• 什么是类

类: 类是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事务特征和行为特征来描述该类事物 现实中，描述一类事物属性：就是事物的状态信息行为：就是事物的功能

• 什么是对象

对象：对象是一类事物的具体体现，对象是类的一个实例，必然具备该事物的属性和行为 现实中,一类事物的一个实例，就是一个对象

• 类和对象的关系

关系：1、类可以看做是一个模板，或者图纸，系统根据类的定义来创造出对象2、类是对一类事物的描述，是抽象的 3、对象是一类事物的实例，是具体的 

1.3 类的定义

• 类的定义

类是现实世界的一类事物属性：事物的状态信息行为：事物的功能和作用Java中用Class描述事物也是如此成员变量：对应事物的属性成员方法：对应事物的行为定义类：就是定义类的成员，包括成员属性和成员方法
成员变量的位置：定义在类中，方法外
成员方法的位置：定义在类中，与之前的方法不一致的是，去掉了static

• 类的定义格式

public class 类的名称{//成员变量//成员方法
}

/*** 类的定义*  定义一个类，用于模拟学生事物，由两部分组成*      学生属性：年龄。升高。体重...*      学生行为：学习、运动、睡觉...*  对应在Java中：*      成员变量：数据类型 变量名;*      成员方法：修饰符 返回值类型 方法名(){}*  注意事项：*      成员变量在类中，方法外*      成员方法不需要写static关键字*/
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.4 对象的使用

• 对象的使用格式

一般情况下，一个类并不能直接使用，需要根据类创建一个对象才能使用创建对象的步骤：- 1、导包：指出使用的类存放的位置,如果在同包中，导包省略- 2、创建：类名称 对象名 = new 类名称();- 3、使用：两种情况- 使用成员变量：对象名.成员变量;- 使用成员方法：对象名.成员方法();
注意事项- 如果成员变量没有赋值，那么就会出现默认值- 整数类型的默认值是0，引用数据类型的默认值是null

*** 对象的使用：*  一般情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用* 创建对象步骤：*  1、导包：指出使用的类存放的位置,如果在同包中，导包省略*  2、创建：类名称 对象名 = new 类名称();*  3、使用：两种情况*      使用成员变量：对象名.成员变量;*      使用成员方法：对象名.成员方法();*  注意事项：如果成员变量没有赋值，那么就会出现默认值，*          整数类型的默认值是0，引用数据类型的默认值是null*/
public class StudentTest {public static void main(String[] args) {//1、导包：和测试类在同包，可以省略//2、创建对象：类名称 对象名 = new 类名称();Student stu1 = new Student();//3、使用：//使用成员变量: 对象名.成员变量;System.out.println(stu1.name);//nummSystem.out.println(stu1.age);//0System.out.println(stu1.address);//nullSystem.out.println("------------------------");//改变对象中的成员变量的属性值stu1.name="Tom";stu1.age=33;stu1.address="北京";System.out.println(stu1.name);//TomSystem.out.println(stu1.age);//33System.out.println(stu1.address);//北京//使用成员方法: 对象名.成员方法();stu1.study();stu1.paly();stu1.sleep();}
}

1.5 类与对象的练习

• 定义一个类，用来模拟”电脑“事物

//模板类
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) {//创建对象格式：类名称 对象名称 = new 类名称();Computer computer = new Computer();//输出成员变量的默认值System.out.println(computer.brand);//nullSystem.out.println(computer.price);//0.0System.out.println(computer.color);//null//修改成员变量的属性值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.6 对象内存图理解

- 对象内存图理解：-  1、先加载Computer类信息`：属性与方法-  2、进行默认初始化，再显示初始化（double price = 5000.0）最后执行构造方法初始化` -  3、把堆中的地址赋给computer，computer就指向对象，computer是对象的引用`，或者叫对象名-  4、当执行到方法时，就会开辟独立的空间（栈）` -  5、方法执行完毕/执行到return就会返回到调用方法的地方`-  6、继续执行后续代码 -  7、当main方法（栈）`执行完毕，程序退出  

1.7 成员变量和局部变量

• 局部变量和成员变量区别

- 1、定义的位置不一样- 局部变量：定义在方法的内部- 成员变量：定义在类的内部，方法的外部
- 2、作用域不一样- 局部变量：只有在方法中才能使用，出了方法不能使用- 成员变量：在整个类中通用
- 3、默认值不一样- 局部变量：没有默认值，必须手动赋值- 成员变量：默认会有初始值
- 4、内存的位置不一样- 局部变量：存储在栈内存- 成员变量：存储在堆内存
- 5、生命周期不一样- 局部变量：随着方法的进栈而诞生，随着方法的出栈而消失- 成员变量：随着对象被创建而诞生，随着对象被垃圾回收器回收被销毁

/*** 局部变量和成员变量的区别*  1、定义的位置不一样*      局部变量：定义在方法的内部*      成员变量：定义在类的内部，方法的外部*  2、作用域不一样*      局部变量：只有在方法中才能使用，出了方法不能使用*      成员变量：在整个类中通用*  3、默认值不一样*      局部变量：没有默认值，必须手动赋值*      成员变量：默认会有初始值*  4、内存的位置不一样*      局部变量：存储在栈内存*      成员变量：存储在堆内存*  5、生命周期不一样：*      局部变量：随着方法的进栈而诞生，随着方法的出栈而消失*      成员变量：随着对象被创建而诞生，随着对象被垃圾回收器回收被销毁*/
public class VariableDemo01 {//成员变量String username;//成员方法public void sleep(){//局部变量int num;//局部变量没有默认值，要使用，需需要手动赋值//System.out.println(num);//Variable 'num' might not have been initialized//作用域：局部变量只在方法中可以使用int num1 = 20;System.out.println(num1);//成员变量在整个类中可以被使用System.out.println(username);//成员变量存在默认值 null}//成员方法传参（参数属于方法的一部分，是局部变量）public void eat(int num2){//此时输出变量num2不报错//原因是，方法被定义之后，需要调用才能被执行//在调用时必须要传参数值，也就是变量接收到数据值，属于手动赋值//所以编译不报错System.out.println(num2);}
}

第二章 封装

2.1 封装的定义

• 封装的定义

封装就是把属于同一类事物的共性放到一个类中，
将不需要对外提供的内容都隐藏起来、
把属性都隐藏，提供公共方法对其访问。

• 封装的好处

将变化隔离、便于使用、提高重用性、提高安全性

• 封装的原则

将不需要对外提供的内容都隐藏起来、
把属性都隐藏，提供公共方法对其访问

2.2 private关键字

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);}//此方法专门用于向age设置值public void setAge(int age) {if (0<=age && age>=100 ){this.age = age;}else {System.out.println("输入的年龄错误");}}//此方法专门获取age的值public int getAge() {return age;}
}

/*** private关键字的使用*/
public class Demo01_Private {public static void main(String[] args) {Person p = new Person();p.name = "张曼玉";//p.age = 22; 被private关键字修饰的成员变量不能在其他类直接访问//System.out.println(p.age);//基于逻辑的合理性，可以在setAge()方法中进行对参数判断p.setAge(-22);System.out.println(p.getAge());}

2.3 this关键字

• this关键字的使用

- 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);}//成员变量和局部变量名称一致时，如果必须使用成员变量，则需要使用this关键字，即：this.成员变量public void sayName3(String name){System.out.println(this.name+"+++"+name);//验证this的身份System.out.println(this);}
}

/*** this关键字的使用*  1、当方法的局部变量和类的成员变量名称相同时，就遵循就近原则，优先使用局部变量*  2、如果必须使用成员变量，则需要使用this关键字，即：this.成员变量*  3、this关键字：指向调用方法的对象，即通过谁调用的方法，this就是谁*/
public class Demo01_This {public static void main(String[] args) {Student s1 = new Student();s1.name = "巩俐";//成员变量的名称与局部变量的名称没有重名s1.sayName1("章子怡");//成员变量的名称和局部变量的名称一致//当方法的局部变量和类的成员变量名称相同时，就遵循就近原则，优先使用局部变量s1.sayName2("关之琳");//成员变量和局部变量名称一致时，如果必须使用成员变量，则需要使用this关键字，即：this.成员变量s1.sayName3("邱淑贞");//验证this是否是当前调用者--即当前对象System.out.println(s1);//打印对象地址值}
}

2.4 构造方法

• 1、构造方法作用

1、是用来专门创建对象的方法
2、当我们通过关键字new来创建对象时，其实就是在调用构造方法

• 2、构造方法格式：

//无参构造
public 类名称(){}
//有参构造
public 类名称(参数类型 参数名,参数类型 参数名){方法体;
}

• 3、注意事项：

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;}
}

/*** 构造方法：*      1、是用来专门创建对象的方法*      2、当我们通过关键字new来创建对象时，其实就是在调用构造方法*  构造方法格式：*      无参构造：public 类名称(){}*      有参构造：public 类名称(参数类型 参数名,参数类型 参数名){方法体}*  注意事项：*      1、构造方法的名称必须和类的名称一致，包含大小写一致*      2、构造方法不需要写返回值类型，包括void*      3。构造方法没有返回值*      4、如果没有声明任何构造方法，编译器会默认提供一个无参数的构造方法供使用*      5、一旦编写任意构造方法，编译器将不提供无参构造方法*      6、如果已经创建有参构造，那么无参构造默认不存在，需要手动定义无参构造*/
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());}
}

2.5 定义标准的类

• 定义一个标准的类

  - 1、所有的成员变量都需要使用private关键字修饰- 2、为每一个成员变量编写一对setter和getter方法- 3、编写一个无参数的构造方法- 4、编写一个全参数的构造方法- 5、这样标准的类，也叫作JavaBean(Java豆子)

/*** 定义一个标准的类*  1、所有的成员变量都需要使用private关键字修饰*  2、为每一个成员变量编写一朵settrt和getter方法*  3、编写一个无参数的构造方法*  4、编写一个全参数的构造方法*  这样标准的类，也叫作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;}//setter和getter方法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());}
}