30天搞定Java--day10

2020-04-01 15:16 238人阅读评论(0)

每日一考和复习

每日一考

什么是方法的重载？

“两同一不同”，类名相同、方法名相同、参数列表不同

说明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

构造器的特征
1. 它具有与类相同的名称
2. 它不声明返回值类型。（与声明为void不同）
3. 不能被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;
	}
}

根据参数不同，构造器可以分为如下两类：
- 隐式无参构造器（系统默认提供）
- 显式定义一个或多个构造器（无参、有参），系统不再提供默认构造器
注意：
1. Java语言中，每个类都至少有一个构造器
2. 默认构造器的修饰符与所属类的修饰符一致
3. 一旦显式定义了构造器，则系统不再提供默认构造器
4. 一个类可以创建多个重载的构造器
5. 父类的构造器不可被子类继承
构造器重载
- 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象
- 构造器重载，参数列表必须不同

// 构造器重载举例
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. 通过“对象.属性”或“对象.方法”的方式赋值
复制的先后顺序
1 -> 2 -> 3 -> 4

扩展：JavaBean

JavaBean是一种Java语言写成的可重用组件
所谓javaBean，是指符合如下标准的Java类
1. 类是公共的
2. 有一个无参的公共的构造器
3. 有属性，且有对应的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访问属性和方法时，如果在本类中未找到，会从父类中查找

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

注意：
1. 可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
2. 明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
3. 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
4. "this(形参列表)"必须声明在类的构造器的首行！
5. 在类的一个构造器中，最多只能声明一个"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组合的使用：调用指定类或接口下的静态的属性或方法

转载：https://blog.csdn.net/weixin_42224119/article/details/105177935

查看评论

飞道的博客