目录
1 封装和隐藏
/*
* 面向对象的特征一：封装与隐藏 3W:what? why? how?
* 一、问题的引入：
* 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()）
* 同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private)-->此时，针对于属性就体现了封装性。
*
* 二、封装性的体现：
* 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
*
* 拓展：封装性的体现：① 不对外暴露的私有的属性 ② 不对外暴露的私有的方法 ③ 单例模式 ...
*
*
* 三、封装性的体现，需要权限修饰符来配合。
* 1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public
* 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类
* 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
* 修饰类的话，只能使用：缺省、public
*
* 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。
*
*/
1.1 私有化+公共方法访问
/**
*
*/
package com.lee.java;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年5月28日上午11:04:59
*/
public class AnimalTest {
public static void main(String[] args) {
Animal a = new Animal();
a.name = "bigH";
//a.age = 1;
//a.legs = 4; 加了private后 这里不可见
a.setLegs(6);
a.show();
//需要禁止不合理的方式
System.out.println(a.getLegs());
//公共方法
a.setAge(10);
a.getAge();
}
}
class Animal{
String name;
private int age;
private int legs;//不会对外暴露，但堆空间还会加载
//专门给legs赋值
public void setLegs(int l){
if (l >= 0 && l % 2 == 0) {
legs = l;
}else{
legs = 0;
}
}
public void eat(){
System.out.println("动物进食");
}
public void show(){
System.out.println("name: " + name +", legs: " + legs + ", age: " + age);
}
public int getLegs(){
return legs;
}
public void setAge(int a){
age = a;
}
public void getAge(){
System.out.println(age);
}
}1.2 不同权限的区别
1.2 例题
通常一个源文件里面写一个类
/**
*
*/
package com.lee.exer;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年5月28日下午8:45:37
*/
public class PersonTest {
public static void main(String[] args) {
Person b = new Person();
b.setAge(120);
System.out.println(b.getAge());
}
}
/**
*
*/
package com.lee.exer;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年5月28日下午8:42:52
*/
public class Person {
private int age;
public void setAge(int a) {
if (a < 0 || a > 130) {
System.out.println("输入不合法！");
} else {
age = a;
}
}
public int getAge() {
return age;
}
public static void main(String[] args) {
}
}
2 构造器
/*
* 类的结构之三：构造器（或构造方法、constructor）的使用
* construct：建设、建造。 construction:CCB constructor:建设者
*
* 一、构造器的作用：
* 1.创建对象
* 2.初始化对象的信息
*
* 二、说明：
* 1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器
* 2.定义构造器的格式：权限修饰符 类名(形参列表){} —— 造对象
* 3.一个类中定义的多个构造器，彼此构成重载
* 4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
* 5.一个类中，至少会有一个构造器。
*/
2.1 练习1
* 2.1. 在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。
* 2.2. 修改上题中类和构造器，增加name属性,使得每次创建Person对象的同时初始化对象的age属性值和name属性值。
/**
*
*/
package com.lee.exer;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年5月28日下午8:45:37
*/
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 + "\t" + p1.age);
//在构造的同时初始化
Person p2 = new Person("Lee", 1);
System.out.println(p2.name + "\t" + p2.age);
}
}
class Person{
//属性
String name;
int age;
//构造器：初始化年龄
public Person(){
System.out.println("调用了构造器！");
age = 18;
}
public Person(String n){
name = n;
age = 18;
}
//构造器：初始化年龄+姓名
public Person(String n,int a){
name = n;
age = a;
}
//方法
public void eat(){
System.out.println("人吃饭");
}
public void study(){
System.out.println("人可以学习");
}
}2.2 属性赋值的先后顺序
/*
* 总结：属性赋值的先后顺序
*
*
* ① 默认初始化
* ② 显式初始化
* ③ 构造器中初始化
* ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
* 以上操作的先后顺序：① - ② - ③ - ④
*/
/**
*
*/
package com.lee.java1;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年5月29日上午9:46:23
*/
public class UserTest {
public static void main(String[] args) {
User u = new User();//默认赋值
System.out.println(u.age);
User u1 = new User(2);
System.out.println(u1.age);
//对象.方法赋值 可以反复执行
u1.setAge(3);
System.out.println(u1.age);
}
}
class User{
//显示赋值
String name;
int age = 1;
public User(){
}
//构造器中赋值
public User(int a){
age = a;
}
public void setAge(int a){
age = a;
}
}
2.3 JavaBEAN
/**
*
*/
package com.lee.java1;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年6月1日上午9:17:03
*/
/**
* JavaBean是一种Java语言写成的可重用组件。
所谓JavaBean，是指符合如下标准的Java类：
>类是公共的
>有一个无参的公共的构造器
>有属性，且有对应的get、set方法
*
*/
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;
}
}
2.4 this
/*
* 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(形参列表)"，用来调用其他的构造器
*
*
*/
/**
*
*/
package com.lee.java2;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年6月1日上午9:28:30
*/
public class PersonTest {
public static void main(String[] args) {
Person p1 = new Person();
p1.setAge(10);
System.out.println(p1.getAge());
p1.eat();
}
}
//this:形参和属性重名的问题
class Person {
private String name;
private int age;
//构造器里面可以调用this
public Person() {
this.eat();
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
public void eat(){
System.out.println("人吃饭");
study();
}
public void study(){
System.out.println("人学习");
}
}
2.5 综合练习1 —— 银行账户
/**
*
*/
package com.lee.exer3;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年6月1日上午9:53:16
*/
//创建账户类
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;
}
/**
* @return the id
*/
public int getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(int id) {
this.id = id;
}
/**
* @return the balance
*/
public double getBalance() {
return balance;
}
/**
* @param balance the balance to set
*/
public void setBalance(double balance) {
this.balance = balance;
}
/**
* @return the annualInterestRate
*/
public double getAnnualInterestRate() {
return annualInterestRate;
}
/**
* @param annualInterestRate the annualInterestRate to set
*/
public void setAnnualInterestRate(double annualInterestRate) {
this.annualInterestRate = annualInterestRate;
}
public void withdraw (double amount) {
if (balance < amount) {
System.out.println("余额不足，取款失败");
return;//不必写else
}
balance -= amount;
System.out.println("成功取出：" + amount);
}
public void deposit (double amount) {
if (amount > 0) {
balance += amount;
System.out.println("成功存入：" + amount);
}
}
}
//创建用户类
public class Customer {
private String firstName;
private String lastName;
private Account account;
public Customer(String f, String l){
this.firstName = f;
this.lastName = l;
}
/**
* @return the account
*/
public Account getAccount() {
return account;
}
/**
* @param account the account to set
*/
public void setAccount(Account account) {
this.account = account;
}
/**
* @return the firstName
*/
public String getFirstName() {
return firstName;
}
/**
* @return the lastName
*/
public String getLastName() {
return lastName;
}
}
//测试
/*
* 写一个测试程序。
（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());
}
}
2.6 综合练习 UML图
/**
*
*/
package exer4;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年6月1日上午10:53:02
*/
public class Account {
private double balance;
public Account(double init_balance){
this.balance = init_balance;
}
/**
* @return the balance
*/
public double getBalance() {
return balance;
}
//存钱
public void deposit(double amt){
if (amt > 0) {
balance += amt;
System.out.println("存钱成功");
}
}
//取钱操作
public void withdraw(double amt){
if (balance > amt) {
balance -= amt;
System.out.println("取钱成功");
} else {
System.out.println("余额不足");
}
}
}
/**
*
*/
package exer4;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年6月1日上午11:00:58
*/
public class Customer {
private String firstName;
private String lastName;
private Account account;
public Customer(String f, String l){
this.firstName = f;
this.lastName = l;
}
/**
* @return the account
*/
public Account getAccount() {
return account;
}
/**
* @param account the account to set
*/
public void setAccount(Account account) {
this.account = account;
}
/**
* @return the firstName
*/
public String getFirstName() {
return firstName;
}
/**
* @return the lastName
*/
public String getLastName() {
return lastName;
}
}
/**
*
*/
package exer4;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年6月1日上午10:53:02
*/
public class Account {
private double balance;
public Account(double init_balance){
this.balance = init_balance;
}
/**
* @return the balance
*/
public double getBalance() {
return balance;
}
//存钱
public void deposit(double amt){
if (amt > 0) {
balance += amt;
System.out.println("存钱成功");
}
}
//取钱操作
public void withdraw(double amt){
if (balance > amt) {
balance -= amt;
System.out.println("取钱成功");
} else {
System.out.println("余额不足");
}
}
}
/**
*
*/
package exer4;
/**
* @Description
* @author LF E-mail:ljjrichard@163.com
* @version
* @date 2021年6月1日上午11:19:23
*/
public class BankTest {
public static void main(String[] args) {
//创建银行类，传入存储大小
Bank icbc = new Bank(10);
icbc.addCustomer("L", "jj");
icbc.addCustomer("L", "f");
//连续操作
icbc.getCustomer(0).setAccount(new Account(2000));
icbc.getCustomer(0).getAccount().withdraw(10);
icbc.getCustomer(1).setAccount(new Account(10000));
//第一位客户的余额是多少
double balance = icbc.getCustomer(0).getAccount().getBalance();
System.out.println("客户 " + icbc.getCustomer(0).getFirstName() +
icbc.getCustomer(0).getLastName() + " 的余额为：" + balance);
//银行有多少位客户
System.out.println("银行的客户个数为：" + icbc.getNumOfCustomers());
}
}
2.7 package
/*
* 一、package关键字的使用
* 1.为了更好的实现项目中类的管理，提供包的概念
* 2.使用package声明类或接口所属的包，声明在源文件的首行
* 3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
* 4.每"."一次，就代表一层文件目录。
*
* 补充：同一个包下，不能命名同名的接口、类。
* 不同的包下，可以命名同名的接口、类。
*
* 二、import关键字的使用
* import:导入
* 1. 在源文件中显式的使用import结构导入指定包下的类、接口
* 2. 声明在包的声明和类的声明之间
* 3. 如果需要导入多个结构，则并列写出即可
* 4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
* 5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
* 6. 如果使用的类或接口是本包下定义的，则可以省略import结构
* 7. 如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。
* 8. 使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
* 9. import static:导入指定类或接口中的静态结构:属性或方法。
*/
2.8 设计模式
533
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
