174.面向对象（上）-每天一考
175.面向对象（上）-复习
176.面向对象（上）-面向对象编程学习的主线
学习面向对象内容的三条主线：
1.Java类及类的成员：属性、方法、构造器；代码块、内部类
2.面向对象的三大特征：封装、继承、多态、（抽象）
3.其它关键字：this、super、static、final、abstract、interface、package、import
177.面向对象（上）-理解面向过程和面向对象
程序员从面向过程的执行者转化成了面向对象的指挥者
面向过程(POP) 与 面向对象(OOP)
- 二者都是一种思想，面向对象是相对于面向过程而言的。
- 面向过程，强调的 是功能行为，以函数为最小单位，考虑怎么做。
- 面向对象，将功能封装进对 象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
- 面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如 抽象、分类、继承、聚合、多态等
面向对象分析方法分析问题的思路和步骤： - 根据问题需要，选择问题所针对的现实世界中的实体。
- 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
- 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序 语言，把类构造成计算机能够识别和处理的数据结构。
- 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具
178.面向对象（上）-两个要素：类和对象
类(Class)和对象(Object)是面向对象的核心概念。
- 类是对一类事物的描述，是抽象的、概念上的定义
- 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。“万事万物皆对象”
179.面向对象（上）-类的结构：属性和方法
常见的类的成员有：
属性：对应类中的成员变量
行为：对应类中的成员方法
Field = 属性 = 成员变量，Method = (成员)方法 = 函数
180.面向对象（上）-类和对象的创建
181.面向对象（上）-对类和对象创建的在理解
182.面向对象（上）-体会类的多个对象的关系
如果创建了一个类的多个对象，则每个对象都独立的拥有一个类的属性，如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
Person p3=p1；
将p1变量保存的地址赋值给p3，导致p3和p1指向了堆空间的同一个对象实体
183.面向对象（上）-对象的内存解析
184.面向对象（上）-属性与局部变量的对比1
185.面向对象（上）-属性与局部变量的对比2
局部变量：没有默认初始化值
- 意味着，我们在调用局部变量之前，一定要显式赋值。
- 特别的，形参在调用时，我们赋值即可。
186.面向对象（上）-方法举例与声明的格式
什么是方法(method、函数):
- 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
- 将功能封装为方法的目的是，可以实现代码重用，简化代码
- Java里的方法不能独立存在，所有的方法必须定义在类里。
187.面向对象（上）-方法声明的说明1
方法的声明格式：
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
方法体程序代码 return 返回值;
｝
修饰符：public,缺省,private, protected等
返回值类型：
- 没有返回值：void。
- 有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用
188.面向对象（上）-方法声明的说明2
方法名：属于标识符，命名时遵循标识符命名规则和规范，“见名知意”
形参列表：可以包含零个，一个或多个参数。多个参数时，中间用“,”隔开
返回值：方法在执行完毕后返还给调用它的程序的数据。
189.面向对象（上）-return关键字的使用
190.面向对象（上）-方法使用中的注意点
- 方法被调用一次，就会执行一次
- 没有具体返回值的情况，返回值类型用关键字void表示，那么方法体中可 以不必使用return语句。如果使用，仅用来结束方法。
- 定义方法时，方法的结果应该返回给调用者，交由调用者处理。
- 方法中只能调用方法或属性，不可以在方法内部定义方法。
191.面向对象（上）-课后练习1：类的设计
192.面向对象（上）-课后练习2：类的设计
193.面向对象（上）-课后练习3：方法的声明
194.面向对象（上）-课后练习4：对象数组
195.面向对象（上）-课后练习4：对象数组的改进
196.面向对象（上）-每天一考1
面向对象的三条主线分别是什么？
类及类的成员：属性、方法、构造器；代码块、内部类
面向对象的三大特征：封装、继承、多态
其它关键字：this、super、abstract、interface、static、final、package、import
谈谈你对面向对象（两个重要的概念）中类和对象的理解，并支出二者的关系
类：抽象的、概念上的内容
对象：实实在在存在的个体（在内存中占据一定的空间）
对象是由类派生出来的
和控制台交互的时候需要Scanner类，真正执行的时候需要创建scanner对象，通过对象操作功能方法，去完成和控制台的交互
面向对象思想的体现一：类和对象的创建和执行操作有哪三步？
- 创建类
- 类的实例化（new）
- 调用对象的结构：“对象.属性”“对象.方法”
197.面向对象（上）-每天一考2
198.面向对象（上）-复习：类与对象
199.面向对象（上）-复习：JVM内存结构与对象内存解析
200.面向对象（上）-复习：属性与方法
相同点：
定义变量的格式：数据类型 变量名=变量值
先声明，后使用
变量都对其对应的作用域
不同点：
在类中声明的位置不同
关于权限修饰符的不同
默认的初始化值的情况不同
在内存中加载的位置
201.面向对象（上）-理解“万事万物”皆对象
在java语言中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
涉及到Java语言与前端Html、后端的数据库交互时、前后端的结构在Java层面交互时，都体现为类、对象。
202.面向对象（上）-对象数组的内存解析
引用类型的变量，只可能存在两类值：null或者地址值（含变量的类型）
203.面向对象（上）-匿名对象的使用
package com.atguigu.java;
/*
* 一、理解“万事万物皆对象”
* 1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
* >Scanner,String等
* >文件：File
* >网络资源：URL
* 2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
*
* 二、内存解析的说明
* 1.引用类型的变量，只可能存储两类值：null 或 地址值（含变量的类型）
*
* 三、匿名对象的使用
* 1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
* 2.特征：匿名对象只能调用一次。
* 3.使用：如下
*/
public class InstanceTest {
public static void main(String[] args) {
Phone p = new Phone();
// p = null;
System.out.println(p);
//正常执行，用的同一个对象，有名字的p
p.sendEmail();
p.playGame();
//匿名对象，调用的不是同一个对象
// new Phone().sendEmail();
// new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//打印0.0
//**********************************
PhoneMall mall = new PhoneMall();
// mall.show(p);
//匿名对象的使用，直接使用新new1的对象调用
mall.show(new Phone());
}
}
//匿名对象的使用，手机商场类
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}
class Phone{
double price;//价格
public void sendEmail(){
System.out.println("发送邮件");
}
public void playGame(){
System.out.println("玩游戏");
}
public void showPrice(){
System.out.println("手机价格为：" + price);
}
}
204.面向对象（上）-自定义数组的工具类
//自定义数组的工具类
public class ArrayUtil {
// 求数组的最大值
public int getMax(int[] arr) {
int maxValue = arr[0];
for (int i = 1; i < arr.length; i++) {
if (maxValue < arr[i]) {
maxValue = arr[i];
}
}
return maxValue;
}
// 求数组的最小值
public int getMin(int[] arr) {
int minValue = arr[0];
for (int i = 1; i < arr.length; i++) {
if (minValue > arr[i]) {
minValue = arr[i];
}
}
return minValue;
}
// 求数组的总和
public int getSum(int[] arr) {
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum;
}
// 求数组的平均值
public int getAvg(int[] arr) {
return getSum(arr) / arr.length;
}
//如下的两个同名方法构成了重载
// 反转数组
public void reverse(int[] arr) {
for (int i = 0; i < arr.length / 2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length - i - 1];
arr[arr.length - i - 1] = temp;
}
}
public void reverse(String[] arr){
}
// 复制数组
public int[] copy(int[] arr) {
int[] arr1 = new int[arr.length];
for (int i = 0; i < arr1.length; i++) {
arr1[i] = arr[i];
}
return arr1;
}
// 数组排序
public void sort(int[] arr) {
// 冒泡排序
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
// int temp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = temp;
//错误的：
// swap(arr[j],arr[j + 1]);
//正确的：
swap(arr,j,j + 1);
}
}
}
}
//错误的：交换数组中指定两个位置元素的值
// public void swap(int i,int j){
// int temp = i;
// i = j;
// j = temp;
// }
//正确的：交换数组中指定两个位置元素的值
public void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
// 遍历数组
public void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + "\t");
}
System.out.println();
}
// 查找指定元素
public int getIndex(int[] arr, int dest) {
// 线性查找：
for (int i = 0; i < arr.length; i++) {
if (dest == arr[i]) {
return i;
}
}
return -1;//返回一个负数，表示没有找到
}
}
205.面向对象（上）-理解方法的重载
重载的概念：
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数 类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类 型)。调用时，根据方法参数列表的不同来区别。
206.面向对象（上）-方法重载的细节说明
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
两同一不同：
同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同举例：
Arrays类中重载的sort() / binarySearch()判断是否是重载：
跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！在通过对象调用方法时，如何确定某一个指定的方法：
方法名 —> 参数列表
207.面向对象（上）-重载的举例与判断练习
208.面向对象（上）-重载的练习：编码实践
209.面向对象（上）-新特性：可变个数形参的方法
JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定 义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可 变的实参。
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);
/*
* 可变个数形参的方法
*
* 1.jdk 5.0新增的内容
* 2.具体使用：
* 2.1 可变个数形参的格式：数据类型 ... 变量名
* 2.2 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
* 2.3 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
* 2.4 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。...与[]之间
* 2.5 可变个数形参在方法的形参中，必须声明在末尾
* 2.6 可变个数形参在方法的形参中,最多只能声明一个可变形参。
*/
public class MethodArgsTest {
public static void main(String[] args) {
MethodArgsTest test = new MethodArgsTest();
test.show(12);
// test.show("hello");
// test.show("hello","world");
// test.show();
//不需要使用该方法了
test.show(new String[]{"AA","BB","CC"});
}
public void show(int i){
}
//和show(String ... strs)对比，传入一个参数时优先调用该方法
public void show(String s){
System.out.println("调用了show(String)方法");
}
//实际上是数组
public void show(String ... strs){
System.out.println("调用了show(String ... strs)方法");
for(int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
//不能与上一个方法同时存在
// public void show(String[] strs){
//
// }
//The variable argument type String of the method
//show must be the last parameter
// public void show(String ...strs,int i){
//
// }
}
210.面向对象（上）-理解变量的赋值
方法，必须由其所在类或对象调用才有意义。若方法含有参数：
形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值
Java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本
（复制品）传入方法内，而参数本身不受影响。
形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);//1001,1001
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);//1002，1002
211.面向对象（上）-值传递机制：针对基本数据类型
/*
* 方法的形参的传递机制：值传递
*
* 1.形参：方法定义时，声明的小括号内的参数
* 实参：方法调用时，实际传递给形参的数据
*
* 2.值传递机制：
* 如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
* 如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。
*
*/
public class ValueTransferTest1 {
public static void main(String[] args) {
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//交换两个变量的值的操作
// int temp = m ;
// m = n;
// n = temp;
ValueTransferTest1 test = new ValueTransferTest1();
test.swap(m, n);
System.out.println("m = " + m + ", n = " + n);
}
public void swap(int m,int n){
int temp = m ;
m = n;
n = temp;
}
}
212.面向对象（上）-值传递机制：针对引用数据类型
public class ValueTransferTest2 {
public static void main(String[] args) {
Data data = new Data();
data.m = 10;
data.n = 20;
System.out.println("m = " + data.m + ", n = " + data.n);//10，20
//交换m和n的值
// int temp = data.m;
// data.m = data.n;
// data.n = temp;
ValueTransferTest2 test = new ValueTransferTest2();
test.swap(data);
System.out.println("m = " + data.m + ", n = " + data.n);
}
public void swap(Data data){
int temp = data.m;
data.m = data.n;
data.n = temp;
}
}
class Data{
int m;
int n;
}
213.面向对象（上）-值传递机制的练习
形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参
214.面向对象（上）-探讨几道网红问题
215.面向对象（上）-参数传递的编码练习
/*
* 考查参数的值传递
*
* 定义一个类PassObject，在类中定义一个方法printAreas()，
* 该方法的定义如下：public void printAreas(Circle c, int time)
* 在printAreas方法中打印输出1到time之间的每个整数半径值，以及对应的面积。
* 例如，time为5，则输出半径1，2，3，4，5，以及对应的圆面积。
*
* 在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示。
*/
public class PassObject {
public static void main(String[] args) {
PassObject test = new PassObject();
Circle c = new Circle();
test.printAreas(c, 5);
System.out.println("now radius is " + c.radius);
}
public void printAreas(Circle c, int time){
System.out.println("Radius\t\tArea");
int i = 1;
for(;i <= time;i++){
//设置圆的半径
c.radius = i;
double area = c.findArea();
System.out.println(c.radius + "\t\t" + area);
}
//
// c.radius = time + 1;
c.radius = i;
}
}
216.面向对象（上）-递归方法的使用
递归方法：一个方法体内调用它自身。
方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
//计算1-100之间所有自然数的和
public int sum(int num){
if(num == 1){
return 1;
}else{
return num + sum(num - 1);
}
}
217.面向对象（上）-递归方法的举例
218.面向对象（上）-每天一考
- 什么是方法的重载？
“两同一不同”：同一个类、相同方法名；参数列表不同。
如何调用确定的方法：方法名参数列表 - 说明Java方法中的参数传递机制的具体体现？
基本数据类型：数据值
引用数据类型：地址值 (含变量的数据类型)
Person p1 = new Person(); eat();age
User u1 = p1;//编译错误 (逆向思维、反证法)
u1.eat() u1.age - 成员变量和局部变量在声明的位置上、是否有默认初始化值上、是否能有权限修饰符修饰上、内存分配的位置上有何不同？
- 谈谈return关键字的使用
① 结束方法 ② 针对于有返回值的方法，return + 返回数据 - 提供如下代码的内存解析
1.内存结构：栈（局部变量）、堆(new出来的结构:对象(非static成员变量)、数组)
2.变量：成员变量 vs 局部变量（方法内、方法形参、构造器内、构造器形参、代码块内）
219.面向对象（上）-复习：重载与可变形参
220.面向对象（上）-值传递与递归方法
封装
221.面向对象（上）-封装性的引入
我们程序设计追求“高内聚，低耦合”。
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提 高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。
222.面向对象（上）-封装性的体现
/*
* 面向对象的特征一：封装与隐藏 3W:what? why? how?
* 一、问题的引入：
* 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到
* 属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值
* 加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
* 同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
* -->此时，针对于属性就体现了封装性。
*
* 二、封装性的体现：
* 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
*
* 拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 ...
*
*
* 三、封装性的体现，需要权限修饰符来配合。
* 1.Java规定的4种权限（从小到大排列）：private、缺省（什么也不写）、protected 、public
* 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
* 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
* 修饰类的话，只能使用：缺省、public
*
* 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
*
*/
public class AnimalTest {
public static void main(String[] args) {
Animal a = new Animal();
a.name = "大黄";
// a.age = 1;
// a.legs = 4;//The field Animal.legs is not visible
a.show();
// a.legs = -4;
// a.setLegs(6);
a.setLegs(-6);
// a.legs = -4;//The field Animal.legs is not visible
a.show();
System.out.println(a.name);
}
}
class Animal{
String name;
private int age;
private int legs;//腿的个数
//对属性的设置
public void setLegs(int l){
if(l >= 0 && l % 2 == 0){
legs = l;
}else{
legs = 0;
// 抛出一个异常（暂时没有讲）
}
}
//对属性的获取
public int getLegs(){
return legs;
}
public void eat(){
System.out.println("动物进食");
}
public void show(){
System.out.println("name = " + name + ",age = " + age + ",legs = " + legs);
}
//提供关于属性age的get和set方法
public int getAge(){
return age;
}
public void setAge(int a){
age = a;
}
}
//private class Dog{
//
//}
223.面向对象（上）-四种权限修饰符的理解
224.面向对象（上）-四种权限修饰符的测试
package com.atguigu.java;
public class Order {
private int orderPrivate;
int orderDefault;
public int orderPublic;
private void methodPrivate(){
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
void methodDefault(){
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
public void methodPublic(){
orderPrivate = 1;
orderDefault = 2;
orderPublic = 3;
}
}
package com.atguigu.java;
public class OrderTest {
public static void main(String[] args) {
Order order = new Order();
order.orderDefault = 1;
order.orderPublic = 2;
//出了Order类之后，私有的结构就不可以调用了
// order.orderPrivate = 3;//The field Order.orderPrivate is not visible
order.methodDefault();
order.methodPublic();
//出了Order类之后，私有的结构就不可以调用了
// order.methodPrivate();//The method methodPrivate() from the type Order is not visible
}
}
225.面向对象（上）-封装性练习：基本使用
构造器
226.面向对象（上）-构造器的基本原理
构造器的作用：创建对象
构造器的特征
- 它具有与类相同的名称
- 它不声明返回值类型。（与声明为void不同）
- 不能被static、final、synchronized、abstract、native修饰，不能有
return语句返回值
构造器的作用：创建对象；给对象进行初始化
- 如：Order o = new Order(); Person p = new Person(“Peter”,15);
- 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的 构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自 动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们 要“洗澡”了。
227.面向对象（上）-构造器使用的细节说明
package com.atguigu.java1;
/*
* 类的结构之三：构造器（或构造方法、constructor）的使用
* construct：建设、建造。 construction:CCB constructor:建设者
*
* 一、构造器的作用：
* 1.创建对象
* 2.初始化对象的信息
*
* 二、说明：
* 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
* 2.定义构造器的格式：权限修饰符 类名(形参列表){}
* 3.一个类中定义的多个构造器，彼此构成重载
* 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
* 5.一个类中，至少会有一个构造器。
*/
public class PersonTest {
public static void main(String[] args) {
//创建类的对象:new + 构造器
Person p = new Person();
p.eat();
Person p1 = new Person("Tom");
System.out.println(p1.name);
}
}
class Person{
//属性
String name;
int age;
//构造器
public Person(){
System.out.println("Person().....");
}
public Person(String n){
name = n;
}
//
public Person(String n,int a){
name = n;
age = a;
}
//方法
public void eat(){
System.out.println("人吃饭");
}
public void study(){
System.out.println("人可以学习");
}
}
228.面向对象（上）-构造器练习：基本使用
229.面向对象（上）-构造器练习：三角形
230.面向对象（上）-总结属性赋值的过程
截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位置，并指明赋值的先后顺序。
赋值的位置：
①默认初始化
②显式初始化
③构造器中初始化
④通过“对象.属性“或“对象.方法”的方式赋值
赋值的先后顺序： ①-② -③-④
231.面向对象（上）-JavaBean的使用
JavaBean是一种Java语言写成的可重用组件。
所谓javaBean，是指符合如下标准的Java类：
类是公共的
有一个无参的公共的构造器
有属性，且有对应的get、set方法
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。
public class Customer {
private int id;
private String name;
//构造器权限默认和类相同
public Customer(){
}
public void setId(int i){
id = i;
}
public int getId(){
return id;
}
public void setName(String n){
name = n;
}
public String getName(){
return name;
}
}
232.面向对象（上）-介绍UML类图
1.+ 表示 public 类型， - 表示 private 类型，#表示protected类型
2.方法的写法:
方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型
233.面向对象（上）-this调用属性和方法
this是什么？
- 在Java中，this关键字比较难理解，它的作用和其词义很接近。
它在方法内部使用，即这个方法所属对象的引用；
它在构造器内部使用，表示该构造器正在初始化的对象。 - this 可以调用类的属性、方法和构造器
- 什么时候使用this关键字呢？
当在方法内需要用到调用该方法的对象时，就用this。
具体的：我们可以用this来区分属性和局部变量。
比如：this.name = name;
/*
* this关键字的使用：
* 1.this可以用来修饰、调用：属性、方法、构造器
*
* 2.this修饰属性和方法：
* this理解为：当前对象 或 当前正在创建的对象
*
* 2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，
* 通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
* 的使用"this.变量"的方式，表明此变量是属性，而非形参。
*
* 2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。
* 但是，通常情况下，我们都选择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式
* 的使用"this.变量"的方式，表明此变量是属性，而非形参。
*
* 3. this调用构造器
* ① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
* ② 构造器中不能通过"this(形参列表)"方式调用自己
* ③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)"
* ④ 规定："this(形参列表)"必须声明在当前构造器的首行
* ⑤ 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器
*/
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.setAge(1);
System.out.println(p1.getAge());
p1.eat();
System.out.println();
Person p2 = new Person("Jerry",20);
System.out.println(p2.getAge());
}
}
class Person{
private String name;
private int age;
public Person(){
// this.eat();
String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
System.out.println(info);
}
public Person(String name){
this();
this.name = name;
}
public Person(int age){
this();
this.age = age;
}
public Person(String name,int age){
this(age);
this.name = name;
//this.age = age;
//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
}
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
public void setAge(int age){
this.age = age;
}
public int getAge(){
return this.age;
}
public void eat(){
System.out.println("人吃饭");
this.study();
}
public void study(){
System.out.println("人学习");
}
}
234.面向对象（上）-this调用构造器
235.面向对象（上）-this练习：Boy和Girl
package com.atguigu.exer2;
public class BoyGirlTest {
public static void main(String[] args) {
Boy boy = new Boy("罗密欧", 21);
boy.shout();
Girl girl = new Girl("朱丽叶", 18);
girl.marry(boy);
Girl girl1 = new Girl("祝英台",19);
int compare = girl.compare(girl1);
if(compare > 0){
System.out.println(girl.getName() + "大");
}else if(compare < 0){
System.out.println(girl1.getName() + "大");
}else{
System.out.println("一样大");
}
}
}
Boy
package com.atguigu.exer2;
public class Boy {
private String name;
private int age;
public Boy() {
}
public Boy(String name) {
this.name = name;
}
public Boy(String name, int age) {
this.name = name;
this.age = age;
}
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 void marry(Girl girl){
System.out.println("我想娶" + girl.getName());
}
public void shout(){
if(this.age >= 22){
System.out.println("你可以去合法登记结婚了！");
}else{
System.out.println("先多谈谈恋爱~~");
}
}
}
Girl
package com.atguigu.exer2;
public class Girl {
private String name;
private int age;
public Girl() {
}
public Girl(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void marry(Boy boy){
System.out.println("我想嫁给" + boy.getName());
boy.marry(this);
}
/**
* @Description 比较两个对象的大小
* @param girl
* @return 正数：当前对象大； 负数：当前对象小 ； 0：当前对象与形参对象相等
*/
public int compare(Girl girl){
// if(this.age > girl.age){
// return 1;
// }else if(this.age < girl.age){
// return -1;
// }else{
// return 0;
// }
return this.age - girl.age;
}
}
236.面向对象（上）-综合练习1：Account和Customer
package com.atguigu.exer3;
/*
* 写一个测试程序。
（1） 创建一个Customer ，名字叫 Jane Smith,
他有一个账号为1000，余额为2000元，年利率为 1.23％ 的账户。
（2） 对Jane Smith操作。
存入 100 元，再取出960元。再取出2000元。
打印出Jane Smith 的基本信息
成功存入 ：100.0
成功取出：960.0
余额不足，取款失败
Customer [Smith, Jane] has a account: id is 1000,
annualInterestRate is 1.23％, balance is 1140.0
*/
public class CustomerTest {
public static void main(String[] args) {
Customer cust = new Customer("Jane", "Smith");
Account acct = new Account(1000, 2000, 0.0123);
cust.setAccount(acct);
cust.getAccount().deposit(100);
cust.getAccount().withdraw(960);
cust.getAccount().withdraw(2000);
System.out.println("Customer[" + cust.getLastName() + "," + cust.getFirstName() +
"] has a account: id is " + cust.getAccount().getId() + ",annualInterestRate is "+
cust.getAccount().getAnnualInterestRate() * 100 + "% ,balance is " + cust.getAccount().getBalance());
}
}
Account
package com.atguigu.exer3;
public class Account {
private int id;//账号
private double balance;//余额
private double annualInterestRate;//年利率
public Account (int id, double balance, double annualInterestRate ){
this.id = id;
this.balance = balance;
this.annualInterestRate = annualInterestRate;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
public double getAnnualInterestRate() {
return annualInterestRate;
}
public void setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
}
//在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
public void withdraw (double amount){//取钱
if(balance < amount){
System.out.println("余额不足，取款失败");
return;
}
balance -= amount;
System.out.println("成功取出：" + amount);
}
public void deposit (double amount){//存钱
if(amount > 0){
balance += amount;
System.out.println("成功存入：" + amount);
}
}
}
Customer
package com.atguigu.exer3;
public class Customer {
private String firstName;
private String lastName;
private Account account;
public Customer(String f,String l){
this.firstName = f;
this.lastName = l;
}
public Account getAccount() {
return account;
}
public void setAccount(Account account) {
this.account = account;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
}
237.面向对象（上）-综合练习2：对象数组
238.面向对象（上）-package关键字的使用
包的作用：
- 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：
MVC的设计模式 - 包可以包含类和子包，划分项目层次，便于管理
- 解决类命名冲突的问题
- 控制访问权限
239.面向对象（上）-MVC设计模式的理解
240.面向对象（上）-import关键字的使用
注意：
1.在源文件中使用import显式的导入指定包下的类或接口
2.声明在包的声明和类的声明之间。
3.如果需要导入多个类或接口，那么就并列显式多个import语句即可
4.举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口。
5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的 是哪个类。
7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
8.import static组合的使用：调用指定类或接口下的静态的属性或方法
版权声明：本文为weixin_46707734原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。