30天搞定Java--day10
文章目录
- 每日一考和复习
- 补充：字符串值变换问题
- 面向对象（接day9）
- 面向对象特征之一：封装与隐藏
- 信息的封装和隐藏
- 四种访问权限修饰符
- 类的成员之三：构造器(或构造方法)
- 总结：属性的复制过程
- 扩展：JavaBean
- 扩展：UML类图
- 关键字：this的使用
- this是什么？
- 使用this调用属性、方法
- 使用this调用本类的构造器
- 练习题
- this练习：Boy and Girl
- 综合练习一：Account_Customer
- 综合练习二：Account_Customer_Bank
- 关键字：package、import的使用
- 关键字--package
- JDK中主要的包介绍（了解）
- MVC设计模式
- 关键字--import
每日一考和复习
每日一考
- 什么是方法的重载？
“两同一不同”，类名相同、方法名相同、参数列表不同
- 说明Java方法中的参数传递机制的具体体现？
java只有“值传递”，数值类型直接传递数值，引用类型传递首地址(含数据类型)
- 成员变量和局部变量在声明的位置上、是否有默认初始化值上、是否能有权限修饰符修饰上、内存分配的位置上有何不同？
| 成员变量 | 局部变量 | |
|---|---|---|
| 声明的位置 | 直接在类内声明 | 在方法内声明 |
| 是否有默认初始化值 | 有 | 无 |
| 是否有权限修改 | 有 | 无 |
| 内存分配的位置 | 堆 | 栈 |
- 谈谈return关键字的使用
结束方法，可顺便结束循环
返回值，可使用变量进行接收
- 提供如下代码的内存解析
public class TransferTest3{
public static void main(String args[]) {
TransferTest3 test = new TransferTest3();
test.first();
}
public void first() {
int i = 5;
Value v = new Value();
v.i = 25;
second(v, i);
System.out.println(v.i);
}
public void second(Value v, int i) {
i = 0;
v.i = 20;
Value val = new Value();
v = val;
System.out.println(v.i + " " + i);
}
}
class Value{
int i = 15;
}
复习
day9的学习内容
补充：字符串值变换问题
// 判断如下代码的输出
public class ValueTransferTest {
public static void main(String[] args) {
String s1 = "hello";
ValueTransferTest test = new ValueTransferTest();
test.change(s1);
System.out.println(s1);
}
public void change(String s) {
s = "hi~~";
}
}
// 按照我们现在的理解String是引用类型，传递地址，应该输出hi~~，但其实输出hello
字符串比较特殊，存储在常量池中，当按照上述方法“修改”字符串时，会新创建字符串“hi~~”而不是将“hello”修改为“hi~~”
面向对象（接day9）
面向对象特征之一：封装与隐藏
我们程序设计追求“高内聚，低耦合”
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉
低耦合 ：仅对外暴露少量的方法用于使用
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性
通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想
信息的封装和隐藏
Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：
- 隐藏一个类中不需要对外提供的实现细节
- 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作
- 便于修改，增强代码的可维护性
封装性的体现
class Animal {
private int legs;// 将属性legs定义为private，只能被Animal类内部访问
public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
if (i != 0 && i != 2 && i != 4) {
System.out.println("Wrong number of legs!");
return;
}
legs = i;
}
public int getLegs() {
return legs;
}
}
public class Zoo {
public static void main(String args[]) {
Animal xb = new Animal();
xb.setLegs(4); // xb.setLegs(-1000);
//xb.legs = -1000; // 非法
System.out.println(xb.getLegs());
}
}
四种访问权限修饰符
Java权限修饰符public、protected、(缺省)、private置于类的成员(属性、方法、构造器、内部类)定义前，用来限定对象对该类成员的访问权限
| 修饰符 | 类内部 | 同一个包 | 不同包的子类 | 同一个工程 |
|---|---|---|---|---|
| private | Yes | |||
| 缺省 | Yes | Yes | ||
| protected | Yes | Yes | Yes | |
| public | Yes | Yes | Yes | Yes |
对于class的权限修饰只可以用public和default(缺省)
- public类可以在任意地方被访问
- default类只可以被同一个包内部的类访问
类的成员之三：构造器(或构造方法)
类的成员之一、之二见day8
- 构造器的特征
- 它具有与类相同的名称
- 它不声明返回值类型。（与声明为void不同）
- 不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值
- 构造器的作用：创建对象；给对象进行初始化
- 如：Order o = new Order(); Person p = new Person(“Peter”,15)
- 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了
语法格式：
修饰符 类名 (参数列表) {
初始化语句；
}
// 举例
public class Animal {
private int legs;
// 构造器
public Animal() {
legs = 4;
}
public void setLegs(int i) {
legs = i;
}
public int getLegs() {
return legs;
}
}
-
根据参数不同，构造器可以分为如下两类：
- 隐式无参构造器（系统默认提供）
- 显式定义一个或多个构造器（无参、有参），系统不再提供默认构造器
-
注 意：
- Java语言中，每个类都至少有一个构造器
- 默认构造器的修饰符与所属类的修饰符一致
- 一旦显式定义了构造器，则系统不再提供默认构造器
- 一个类可以创建多个重载的构造器
- 父类的构造器不可被子类继承
-
构造器重载
- 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象
- 构造器重载，参数列表必须不同
// 构造器重载举例
public class Person{
public Person(String name, int age, Date d) {this(name,age);…}
public Person(String name, int age) {…}
public Person(String name, Date d) {…}
public Person(){…}
}
练习题目
/*
* 编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，
* 同时声明公共方法访问私有变量。
* 此外，提供类必要的构造器。另一个类中使用这些公共方法，获得三角形的长和高。
*/
// TriAngle.java
package com.water.exer1;
public class TriAngle {
private double base;// 底边长
private double height;// 高
public TriAngle() {
}
public TriAngle(double b, double h) {
base = b;
height = h;
}
public void setBase(double b) {
base = b;
}
public double getBase() {
return base;
}
public void setHeight(double h) {
height = h;
}
public double getHeight() {
return height;
}
}
// TriAngleTest.java
package com.water.exer1;
public class TriAngleTest {
public static void main(String[] args) {
TriAngle t1 = new TriAngle();
t1.setBase(2.0);
t1.setHeight(2.4);
System.out.println("base : " + t1.getBase() + ",height : " + t1.getHeight());
TriAngle t2 = new TriAngle(5.1, 5.6);
System.out.println("base : " + t2.getBase() + ",height : " + t2.getHeight());
}
}
总结：属性的复制过程
截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位置，并指明赋值的先后顺序
-
赋值的位置
- 默认初始化
- 显示初始化
- 构造器中初始化
- 通过“对象.属性”或“对象.方法”的方式赋值
-
复制的先后顺序
1 -> 2 -> 3 -> 4
扩展：JavaBean
-
JavaBean是一种Java语言写成的可重用组件
-
所谓javaBean，是指符合如下标准的Java类
- 类是公共的
- 有一个无参的公共的构造器
- 有属性，且有对应的get、set方法
-
用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变
扩展：UML类图
- +表示 public 类型， - 表示 private 类型，#表示protected类型
- 方法的写法:
方法的类型(+、-) 方法名(参数名： 参数类型)：返回值类型
关键字：this的使用
this是什么？
- 在Java中，this关键字比较难理解，它的作用和其词义很接近。
- 它在方法内部使用，即这个方法所属对象的引用
- 它在构造器内部使用，表示该构造器正在初始化的对象
- this 可以调用类的属性、方法和构造器
- 什么时候使用this关键字呢？
- 当在方法内需要用到调用该方法的对象时，就用this。
具体的：我们可以用this来区分属性和局部变量。
比如：this.name = name;
- 当在方法内需要用到调用该方法的对象时，就用this。
使用this调用属性、方法
- 在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this
- 当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量
- 使用this访问属性和方法时，如果在本类中未找到，会从父类中查找
class Person { // 定义Person类
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void getInfo() {
System.out.println("姓名：" + name);
this.speak();
}
public void speak() {
System.out.println("年龄" + this.age);
}
}
使用this调用本类的构造器
- this可以作为一个类中构造器相互调用的特殊格式
class Person { // 定义Person类
private String name;
private int age;
public Person() { // 无参构造器
System.out.println("新对象实例化");
}
public Person(String name) {
this(); // 调用本类中的无参构造器
this.name = name;
}
public Person(String name, int age) {
this(name); // 调用有一个参数的构造器
this.age = age;
}
public String getInfo() {
return "姓名：" + name + "，年龄：" + age;
}
}
- 注意：
- 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
- 明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
- 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
- "this(形参列表)"必须声明在类的构造器的首行！
- 在类的一个构造器中，最多只能声明一个"this(形参列表)"
练习题
this练习：Boy and Girl
// Boy.java
package com.water.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.java
package com.water.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 比较两个对象的大小
* @author water
* @date 2020年3月29日下午6:35:00
* @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;
}
}
// BoyGirlTest.java
package com.water.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("一样大");
}
}
}
综合练习一：Account_Customer
1.写一个名为 Account 的类模拟账户。该类的属性和方法如下图所示。该类包括的属性：账号 id，余额 balance，年利率 annualInterestRate；包含的方法：访问器方法（getter 和 setter方法），取款方法 withdraw()，存款方法 deposit()
提示：在提款方法 withdraw 中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示
2.创建 Customer 类
3.写一个测试程序
（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
// Account.java
package com.water.exer_ac;
public class Account {
private int id; // 账号
private double balance;// 余额
private double annuallnterestRate;// 年利率
public Account(int id,double balance,double annuallnterestRate) {
this.id = id;
this.balance = balance;
this.annuallnterestRate = annuallnterestRate;
}
public int getId() {
return this.id;
}
public void setId(int id) {
this.id = id;
}
public double getBalance() {
return this.balance;
}
public void setBanlance(double balance) {
this.balance = balance;
}
public double getAnnuallnterestRate() {
return this.annuallnterestRate;
}
public void setAnnuallnterestRate(double AnnuallnterestRate) {
this.annuallnterestRate = AnnuallnterestRate;
}
/**
*
* @Description 取钱
* @author water
* @date 2020年3月29日下午7:54:35
* @param amount
*/
public void withdraw(double amount) {
if(amount > this.balance) {
System.out.println("余额不足，取款失败");
return;
}
this.balance -= amount;
System.out.println("成功取出：" + amount);
}
/**
*
* @Description 存钱
* @author water
* @date 2020年3月29日下午7:54:21
* @param amount
*/
public void deposit(double amount) {
this.balance += amount;
System.out.println("成功存入 ：" + amount);
}
}
// Customer.java
package com.water.exer_ac;
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 String getFirstName() {
return this.firstName;
}
public String getLastName() {
return this.lastName;
}
public Account getAccount() {
return this.account;
}
public void setAccount(Account account) {
this.account = account;
}
}
// AccountCustomerTest.java
package com.water.exer_ac;
public class AccountCustomerTest {
public static void main(String[] args) {
Customer jane = new Customer("Jane", "Smith");
Account account = new Account(1000, 2000, 1.23);
jane.setAccount(account);
jane.getAccount().deposit(100.0);
jane.getAccount().withdraw(960.0);
jane.getAccount().withdraw(2000.0);
System.out.println("Customer [" + jane.getLastName() + "," + jane.getFirstName() + "] has a account: id is "
+ jane.getAccount().getId() + ", annualInterestRate is " + jane.getAccount().getAnnuallnterestRate()
+ "％, \r\n" + "balance is " + jane.getAccount().getBalance());
}
}
// 结果
成功存入 ：100.0
成功取出：960.0
余额不足，取款失败
Customer [Smith,Jane] has a account: id is 1000, annualInterestRate is 1.23％,
balance is 1140.0
综合练习二：Account_Customer_Bank
1.按照如下的 UML 类图，创建相应的类，提供必要的结构
在提款方法 withdraw()中，需要判断用户余额是否能够满足提款数额的要求，如果不能，
应给出提示。deposit()方法表示存款。
2.按照如下的 UML 类图，创建相应的类，提供必要的结构
3.按照如下的 UML 类图，创建相应的类，提供必要的结构
- addCustomer 方法必须依照参数（姓，名）构造一个新的 Customer 对象，然后把它放到customer 数组中。还必须把 numberOfCustomer 属性的值加 1
- getNumOfCustomers 方法返回 numberofCustomers 属性值
- getCustomer 方法返回与给出的 index 参数相关的客户
4.创建 AccountCustomerBankTest 类，进行测试
package com.water.acb;
public class Account {
private double balance;
public Account(double balance) {
this.balance = balance;
}
public double getBalance() {
return this.balance;
}
/**
*
* @Description 存钱
* @author water
* @date 2020年3月29日下午9:12:25
* @param amt：存入的金额
*/
public void deposit(double amt) {
if (amt < 0) {
System.out.println("输入错误");
return;
}
this.balance += amt;
System.out.println("成功存入 ：" + amt);
}
/**
*
* @Description 取钱
* @author water
* @date 2020年3月29日下午9:14:41
* @param amt：取的金额
*/
public void withdraw(double amt) {
if (amt > this.balance) {
System.out.println("余额不足，取款失败");
return;
}
this.balance -= amt;
System.out.println("成功取出：" + amt);
}
}
package com.water.acb;
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 String getFirstName() {
return this.firstName;
}
public String getLastName() {
return this.lastName;
}
public Account getAccount() {
return this.account;
}
public void setAccount(Account acct) {
this.account = acct;
}
}
package com.water.acb;
public class Bank {
private Customer[] customers = new Customer[10];
private int numberOfCustomer;
public Bank() {
}
/**
*
* @Description 增加客户
* @author water
* @date 2020年3月29日下午9:38:43
* @param f firstName
* @param l lastName
*/
public void addCustomer(String f, String l) {
Customer customer = new Customer(f, l);
this.customers[this.numberOfCustomer] = customer;
this.numberOfCustomer += 1;
}
/**
*
* @Description 返回银行中现有客户的数量
* @author water
* @date 2020年3月29日下午9:35:09
* @return numberOfCustomer
*/
public int getNumOfCustomers() {
return this.numberOfCustomer;
}
/**
*
* @Description 返回指定客户
* @author water
* @date 2020年3月29日下午9:36:25
* @param index:指定索引
* @return
*/
public Customer getCustomer(int index) {
if (index < this.numberOfCustomer && index >= 0) {
return this.customers[index];
}
System.out.println("输入无效");
return null;
}
}
package com.water.acb;
public class AccountCustomerBankTest {
public static void main(String[] args) {
// 创建三个账户实例
Account acct1 = new Account(1000);
Account acct2 = new Account(300);
Account acct3 = new Account(5000);
// 创建银行
Bank bank = new Bank();
// 银行关联客户
bank.addCustomer("cust1", "cust1");
bank.addCustomer("cust2", "cust2");
bank.addCustomer("cust3", "cust3");
// 得到三个客户
Customer cust1 = bank.getCustomer(0);
Customer cust2 = bank.getCustomer(1);
Customer cust3 = bank.getCustomer(2);
// 客户关联账户
cust1.setAccount(acct1);
cust2.setAccount(acct2);
cust3.setAccount(acct3);
// 测试方法--余额
System.out.println("cust1余额：" + cust1.getAccount().getBalance());
System.out.println("cust2余额：" + cust2.getAccount().getBalance());
System.out.println("cust3余额：" + cust3.getAccount().getBalance());
// 测试方法--存钱
cust1.getAccount().deposit(100);
cust2.getAccount().deposit(1100);
cust3.getAccount().deposit(-100);
// 测试方法--取钱
cust1.getAccount().withdraw(2000);
cust2.getAccount().withdraw(200);
cust3.getAccount().withdraw(8000);
// 验证答案
System.out.println("cust1余额：" + cust1.getAccount().getBalance());
System.out.println("cust2余额：" + cust2.getAccount().getBalance());
System.out.println("cust3余额：" + cust3.getAccount().getBalance());
// 测试方法--获取银行客户人数
System.out.println("银行现在有" + bank.getNumOfCustomers() + "个人");
}
}
关键字：package、import的使用
关键字–package
-
package语句作为Java源文件的第一条语句，指明该文件中定义的类所在的包。(若缺省该语句，则指定为无名包)。它的格式为：
package 顶层包名.子包名; -
包对应于文件系统的目录，package语句中，用 “.” 来指明包(目录)的层次；
-
包通常用小写单词标识。通常使用所在公司域名的倒置：com.water.xxx
包的作用：
- 包帮助管理大型软件系统：将功能相近的类划分到同一个包中。比如：MVC的设计模式
- 包可以包含类和子包，划分项目层次，便于管理
- 解决类命名冲突的问题
- 控制访问权限
JDK中主要的包介绍（了解）
- java.lang----包含一些Java语言的核心类，如String、Math、Integer、 System和Thread，提供常用功能
- java.net----包含执行与网络相关的操作的类和接口
- java.io ----包含能提供多种输入/输出功能的类
- java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数
- java.text----包含了一些java格式化相关的类
- java.sql----包含了java进行JDBC数据库编程的相关类/接口
- java.awt----包含了构成抽象窗口工具集（abstract window toolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)
MVC设计模式
MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，与数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性
模型层 model 主要处理数据
数据对象封装 model.bean/domain
数据库操作类 model.dao
数据库 model.db
视图层 view 显示数据
相关工具类 view.utils
自定义view view.ui
控制层 controller 处理业务逻辑
应用界面相关 controller.activity
存放fragment controller.fragment
显示列表的适配器 controller.adapter
服务相关的 controller.service
抽取的基类 controller.base
关键字–import
-
为使用定义在不同包中的Java类，需用import语句来引入指定包层次下所需要的类或全部类(.*)。import语句告诉编译器到哪里去寻找类
-
语法格式：
import 包名. 类名; -
注意：
- 在源文件中使用import显式的导入指定包下的类或接口
- 声明在包的声明和类的声明之间
- 如果需要导入多个类或接口，那么就并列显式多个import语句即可
- 举例：可以使用java.util.*的方式，一次性导入util包下所有的类或接口
- 如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句
- 如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类
- 如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入
- import static组合的使用：调用指定类或接口下的静态的属性或方法