九、关键字：this的使用

  1. package com.atguigu.java2;
  2. /*
  3.  * this关键字的使用
  4.  * 1. this可以用来修饰、调用：属性、方法、构造器
  5.  * 
  6.  * 2. this修饰属性和方法：
  7.  *     this理解为:当前对象 或 当前正在创建的对象
  8.  *     
  9.  *     2.1 在类的方法当中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象的属性或方法
  10.  *     但是，通常情况下，选择省略"this."。特殊情况下，如果方法的形参和属性同名，我们必须显示使用
  11.  *     "this.变量"的方式,表明此变量是属性，而非形参
  12.  * 
  13.  *     2.2 在类的构造器当中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象的属性或方法
  14.  *     但是，通常情况下，选择省略"this."。特殊情况下，如果构造器的形参和属性同名，我们必须显示使用
  15.  *     "this.变量"的方式,表明此变量是属性，而非形参
  16.  * 
  17.  * 3. this调用构造器
  18.  *     3.1 我们在类的构造器中，可以显示的使用"this(形参列表)"方式，调用本类中指定的其他构造器
  19.  *     3.2 构造器中不能通过"this(形参列表)"方式,调用自己
  20.  *     3.3 如果一个类中有n个构造器，则最多有n-1构造器中使用"this(形参列表)"
  21.  *     3.4 规定："this(形参列表)"必须在当前构造器首行
  22.  *     3.5 构造器内部，最多只能声明一个"this(形参列表)"，用来调用其他的构造器
  23.  */
  24. public class PersonTest {
  25.     public static void main(String[] args) {
  26.         Person p1 = new Person();
  28.         p1.setAge(1);
  29.         System.out.println(p1.getAge());
  31.         p1.eat();
  33.         System.out.println();
  35.         Person p2 = new Person("Jerrmy",20);
  36.     }
  37. }
  39. class Person{
  40.     private String name;
  41.     private int age;
  43.     public Person(){
  44.         //this.eat();
  45.         String info = "Person初始化时，需要考虑如下1，2，3，4（共40行代码）";
  46.         System.out.println(info);
  47.     }
  49.     //构造器没有返回值
  50.     public Person(String name){
  51.         this();//调用空参构造器、且必须在当前构造器首行
  52.         this.name = name;
  53.         //Person初始化时，需要考虑如下1，2，3，4（共40行代码）
  54.     }
  56.     public Person(int age){
  57.         this();
  58.         this.age = age;
  59.         //Person初始化时，需要考虑如下1，2，3，4（共40行代码）
  60.     }
  62.     public Person(String name,int age){
  63.         this(age);
  64.         this.name = name;
  65.         //this.age = age;
  66.         //Person初始化时，需要考虑如下1，2，3，4（共40行代码）
  67.     }
  69.     public void setName(String name){
  70.         this.name = name;
  71.     }
  73.     public String getName(){
  74.         return name;
  75.     }
  77.     public void setAge(int age){
  78.         this.age = age;
  79.     }
  81.     public int getAge(){
  82.         return age;
  83.     }
  85.     public void eat(){
  86.         System.out.println("人吃饭");
  87.         this.study();
  88.     }
  90.     public void study(){
  91.         System.out.println("人学习");
  92.     }
  93. }

9.1 练习11

  1. package com.atguigu.exer2;
  3. public class Boy {
  4.     private String name;
  5.     private int age;
  7.     public Boy() {
  9.     }
  11.     public Boy(String name,int age){
  12.         this.name = name;
  13.         this.age = age;
  14.     }
  16.     public String getName() {
  17.         return name;
  18.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  22.     public int getAge() {
  23.         return age;
  24.     }
  25.     public void setAge(int age) {
  26.         this.age = age;
  27.     }
  29.     public void marry(Girl girl){
  30.         System.out.println("我想娶" + girl.getName());
  31.     }
  33.     public void shout(){
  34.         if(this.age >= 22){
  35.             System.out.println("你可以登记结婚了");
  36.         }else{
  37.             System.out.println("多谈谈恋爱");
  38.         }
  39.     }
  40. }
  1. package com.atguigu.exer2;
  3. public class Girl {
  4.     private String name;
  5.     private int age;
  9.     public Girl(){
  11.     }
  13.     public Girl(String name,int age){
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  20.     public void setName(String name) {
  21.         this.name = name;
  22.     }
  24.     public void marry(Boy boy){
  25.         System.out.println("我想嫁给" + boy.getName());
  26.         boy.marry(this);//传递的是Girl类型，this表示当前对象
  27.     }
  29.     public int compare(Girl girl){
  30.         /*if(this.age > girl.age){
  31.             return 1;
  32.         }else if(this.age < girl.age){
  33.             return -1;
  34.         }else {
  35.             return 0;
  36.         }*/
  38.         return this.age - girl.age;    
  39.     }
  40. }
  1. package com.atguigu.exer2;
  3. public class BoyGirlTest {
  5.     public static void main(String[] args) {
  7.         Boy boy = new Boy("罗密欧", 21);
  8.         boy.shout();
  10.         Girl girl = new Girl("朱丽叶", 18);
  11.         girl.marry(boy);
  13.         Girl girl1 = new Girl("祝英台", 18);
  14.         int compare = girl.compare(girl1);
  15.         if(compare > 0){
  16.             System.out.println(girl.getName() + "大");
  17.         }else if(compare > 0){
  18.             System.out.println(girl1.getName() + "大");
  19.         }else{
  20.             System.out.println("一样大");
  21.         }
  22.     }
  23. }

9.2 实验1

9.3 实验2（难、收获大）

1.按照如下的 UML 类图，创建相应的类，提供必要的结构

4.（this、package、import） - 图1

在提款方法 withdraw()中，需要判断用户余额是否能够满足提款数额的要求，如果不能，

应给出提示。deposit()方法表示存款。

2.按照如下的 UML 类图，创建相应的类，提供必要的结构

4.（this、package、import） - 图2

  1. 按照如下的 UML 类图，创建相应的类，提供必要的结构
    4.（this、package、import） - 图3

    • addCustomer 方法必须依照参数（姓，名）构造一个新的 Customer 对象，然后把
      它放到 customer 数组中。还必须把 numberOfCustomer 属性的值加 1。

    • getNumOfCustomers 方法返回 numberofCustomers 属性值。

    • getCustomer 方法返回与给出的 index 参数相关的客户。

  2. 创建 BankTest 类，进行测试。
    Account

  1. package com.atguigu.exer4;
  3. public class Account {
  5.     private double balance;
  7.     public Account(double init_balance){
  8.         this.balance = init_balance;
  9.     }
  11.     public double getBalance(){
  12.         return balance;
  13.     }
  15.     //存钱操作
  16.     public void deposit(double amt){
  17.         if(amt > 0){
  18.             balance += amt;
  19.         }
  20.     }
  22.     //取钱操作
  23.     public void withdraw(double amt){
  24.         if(balance >= amt){
  25.             balance -= amt;
  26.             System.out.println("取钱成功");
  27.         }else{
  28.             System.out.println("余额不足");
  29.         }    
  30.     }
  31. }

Bank类

  1. package com.atguigu.exer4;
  3. public class Bank {
  4.     private Customer[] customers;//存放多个数组
  5.     private int numerOfCustomer;//记录客户个数
  7.     public Bank(){
  8.         customers = new Customer[10];
  9.     }
  11.     //添加客户
  12.     public void addCustomer(String f,String l){
  13.         Customer cust = new Customer(f,l);//new一个,创建对象
  14.         //报空指针异常，数组没有初始化
  15.         customers[numerOfCustomer++] = cust;//存放地址
  16.     }
  18.     //获取指定位置上客户
  19.     public Customer getCustomer(int index) {
  20.         if(index >= 0 && index <= numerOfCustomer){
  21.             return customers[index]; 
  22.         }
  24.         return null;
  26.     }
  28.     public int getNumerOfCustomer() {
  29.         return numerOfCustomer;
  30.     }    
  31. }

Customer类

  1. package com.atguigu.exer4;
  3. public class Customer {
  4.     private String firstName;
  5.     private String lastName;
  6.     private Account account;
  8.     public Customer(String f, String l){
  9.         this.firstName = f;
  10.         this.lastName = l;
  11.     }
  13.     public Account getAccount() {
  14.         return account;
  15.     }
  17.     public void setAccount(Account account) {
  18.         this.account = account;
  19.     }
  21.     public String getFirstName() {
  22.         return firstName;
  23.     }
  25.     public String getLastName() {
  26.         return lastName;
  27.     }    
  28. }

BankTest类

  1. package com.atguigu.exer4;
  3. public class BankTest {
  4.     public static void main(String[] args) {
  5.         Bank bank = new Bank();
  7.         bank.addCustomer("Jane","Smith");
  8.         //匿名对象
  9.         bank.getCustomer(0).setAccount(new Account(2000));
  11.         bank.getCustomer(0).getAccount().withdraw(500);
  13.         double balance = bank.getCustomer(0).getAccount().getBalance();
  14.         System.out.println("客户 ：" + bank.getCustomer(0).getFirstName() + 
  15.                 "账户的余额为：" + balance);
  17.         System.out.println("***************************");
  19.         bank.addCustomer("万里", "鹏程");
  20.         System.out.println("银行客户个数为 " + bank.getNumerOfCustomer());
  21.     }    
  22. }

十、关键字：package、 import的使用

  1. package com.atguigu.java2;
  3. //import的落脚点是类或接口
  4. import java.lang.reflect.Field;
  5. import java.util.*;
  7. import com.atguigu.exer4.Account;
  8. import com.atguigu.java2.java3.Dog;
  10. //import static的落脚点是类中的结构
  11. import static java.lang.System.*;
  12. import static java.lang.Math.*;
  15. /*import java.util.ArrayList;
  16. import java.util.Arrays;
  17. import java.util.HashMap;*/
  19. /*
  20.  * 一、package关键字的使用
  21.  * 1.为了更好的实现项目中类的管理，提供包的概念
  22.  * 2.使用package声明类或接口所属的包，声明在源文件的首行
  23.  * 3.包，属于标识符，遵循标识符的命名规则、规范（xxxyyyzzz）、“见名知意”
  24.  * 4.每“.”一次，就代表一层文件目录。
  25.  * 
  26.  * 补充：同一个包下，不能命名同名的接口、类
  27.  *         不同包下，可以命名同名的接口、类
  28.  * 
  29.  * 二、import关键字的使用
  30.  * import:导入
  31.  * 1.在源文件中显示的使用import结构导入指定包下的类、接口
  32.  * 2.声明在包的声明和类的声明之间
  33.  * 3.如果需要导入多个结构，则并列写出即可
  34.  * 4.可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构
  35.  * 5.如果使用的是类或接口是java.lang包下定义的，则可以省略import结构
  36.  * 6.如果使用的类或接口是本包下定义的，则可以省略import结构
  37.  * 7.如果在源文件中，使用不同包下的同名的类则必须至少有一个类需要以全类名的方式显示
  38.  * 8.使用"xxx.*"方式表明可以调用xxx包下的所有结构。但如果使用的是xxx子包下的结构，则
  39.  *     仍需要显示调用，"xxx.*"指表示xxx包下的类或接口，不表示子包
  40.  * 
  41.  * 9.import static：导入指定类或接口中的静态结构：属性或方法
  42.  */
  45. public class PackageImportTest {
  46.     public static void main(String[] args) {
  47.         String info = Arrays.toString(new int[]{1,2,3}); 
  49.         ArrayList list = new ArrayList();
  50.         HashMap map = new HashMap();
  52.         Scanner s = null;
  54.         System.out.println("hello");
  56.         Account acct = new Account(1000);
  57.         //全类名的方式显示
  58.         //com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000,2000,0.0123);
  60.         //要导入，应为是com.atguigu.java2的子包下的结构
  61.         Dog dog = new Dog();
  63.         //lang包不用导，但是lang包下的子包仍然需要导包，和上一行一样
  64.         Field field = null;
  66.         //导入import static java.lang.System.*;
  67.         out.println();
  69.         //import static java.lang.Math.*;
  70.         //long num = Math.round(123.45);
  71.         long num = round(123.45);        
  72.     }
  73. }

第239-257 262 263 268 269还没看，先学继承从258