尚硅谷java零基础入门从221p开始的笔记

标签：221p java String int age void 硅谷 public name

221*** 面向对象上四种权限修饰的理解封装性的体现需要权限修饰符来配合 1.java规定的四种权限（从小到大排列） private，缺省，protected，public public类可以在任意地方被访问 private类内部缺省类内部同一个包 protected 类内部同一个包不同包的子类四种权限可以修饰类及类的内部结构：属性，方法，构造器，内部类修饰类的话只能使用：缺省，public

222 四种权限修饰的测试

public class Order {
     private int orderPrivate;
     int orderDefault;
     public int orderPublic;

     private void methodPrivate(){
        orderPrivate=1;
        orderDefault=2;
        orderPubilc=3;
        }
        void methodDefault(){
         orderPrivate=1;
        orderDefault=2;
        orderPubilc=3;
        }
        public void methodPublic(){
         orderPrivate=1;
        orderDefault=2;
        orderPubilc=3;
        }
        }

public class OrderTest {
  public static void main(String[] args) {
      Order order=new Order;
      order.orderDefault=1;
      order.orderPublic=2;
      //私有的结构不能调用
      order.orderPrivate=3;
      order.methodDefault();
      order.methodPublic();
    }

总结封装性
java提供了四种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构再被调用时的可见性的大小

223 封装性练习基本使用

1.创建程序,在其中定义两个类：Person 和 PersonTest 类。
定义如下：用 setAge()设置人的合法年龄(0~130)，用 getAge()返回人的年龄。

//设置
public class Person {
 private int age;
 public void setAge(int a){
       if(a<0||a>130){
       System.out.println("传入的数据非法!");
       return;
       }
       age=a;
       }
//获取
       public int getAge(){
       return age;
       }

在 PersonTest 类中实例化 Person 类的对象 b，
调用 setAge()和 getAge()方法，体会 Java 的封装性。
*/

public class PersonTest{
 public static void main(String[] args) {
 Person p1=new Person();
 //p1.age=1; 编译不通过
 p1.setAge(12);\
 System.out.println("年龄为:"+p1.getAge());
 }
 }

224 构造器的基本理解

任何一个类都有构造器
类的结构之三：构造器
constructor：建设，建造，建设者
construction
一:构造器的作用
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("人可以学习");
}
}

226 构造器练习：基本使用

/* 2.在前面定义的 Person 类中添加构造器，

* 利用构造器设置所有人的 age 属性初始值都为 18。 * */

public class Person{
   private int age;
   public Person(){
      age=18;
   }
public class PersonTest{
public static void main(String[] args){
       Person p1=new Person();
       System.out.println("年龄为:"+p1.getAge());
 }
}

/* 3.修改上题中类和构造器，增加 name 属性, *

使得每次创建 Person 对象的同时初始化对象的 age 属性值和 name 属性值。 */

public class Person{
    private int age;
    private String name;
public Person(){
   age=18;
   }
   public Person(String n,int a){
           name=n;
           age=a;
}
\\封装性
public void setName(String n){
      name=n;
}
public String getName(){
   return name;
}
\\测试层面
public class PersonTest {
    public static void main(String[] args){
    Person p1=new Person();
    p1.setAge(12);
    System.out.println("年龄为:"+p1.getAge());
    Person p2=new Person("Tom',21);
    System.out.println("name="+p2.getName()+",age="+p2.getAge);
}

227 构造器练习三角形

/*
* 编写两个类，TriAngle 和 TriAngleTest，
* 其中 TriAngle 类中声明私有的底边长 base 和高 height，同时声明公共方法访问私有变量。
* 此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。
*
*/

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

\\测试
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());
}
}

228 总结属性赋值的过程

//总结属性赋值的先后顺序
1.默认初始化值
2.显式初始化
3.构造器中赋值
4.通过对象.方法或者对象.属性的方式赋值
先后顺序   1-2-3-4  
//
public class UserTest{
     public static void main(String[] args){
                User u=new User();
                System.out.println(u.age);
                User u1=new User(2);
                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;
}

229 javabean的使用

1.类是公共的

2.有一个无参的公共的构造器

3.有属性，且有对应的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;
     }
}

230 介绍UML类图

尚硅谷java零基础入门从221p开始的笔记_开发语言

231 this调用属性和方法

关键字

public class PersonTest{
  public static void main(String[] args){
          Person p1=new Person();
          p1.setAge(1);
          System.out.println(p1.getage());
    }
}
class Person{
  private String name;
  private int age;
  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;
  }

this关键字的使用

1.this可以用来修饰属性，方法，构造器

2.this修饰属性和方法：

this理解为：当前对象或当前正在创建的对象

2.1在类的方法中可以使用"this.属性"或 "this.方法"的方式，调用当前对象属性或方法，但是，通常情况下，我们都选择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用this.变量的方式，表明此变量是属性，而非形参

public class PersonTest{
  public static void main(String[] args){
          Person p1=new Person();
          p1.setAge(1);
          System.out.println(p1.getage());
    }
}
class Person{
  private String name;
  private int age;
  public Person(){
   }
   public Person(String name){
             this.age=age;
  }
  public Person(String name,int age){
          this.name=name;
          this.age=age;
  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;
  }

232 this调用构造器

3.this调用构建器

3.1我们在类的构造器中，可以显式的使用this（形参列表）方式，调用本类中指定的其他构造器

构造器中不能通过this形参列表

如果一个类中有n个构造器，则最多有n-1构造器中使用了this形参列表

规定：this形参列表必须声明在当前构造器的首行

构造器内部：最多只能声明一个形参列表，用来调其他的构造器

233 this练习 boy和girl

尚硅谷java零基础入门从221p开始的笔记_开发语言_02

public class Boy{
         private String name;
         private int 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(age>=22){
               System.out.println("你可以去合法登记结婚了");
             }else{
               System.out.println("先多谈谈恋爱");
             }
}

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);
           }
//比较两个对象的大小
//正数：当前对象大；负数：当前对象小；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;


//测试
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("一样大");
           }
   }
}

234 综合练习1 account和customer

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


public class Customer{
         private String firstname;
         private String lastname;
         private Account account;
         public Customer(String f,String l){
                 this.firstName=f;
                 this.lastName=1;
         }
         public Account getAccount(){
            return account;
         }
         public void setAccount(Account account){
             this.account=account;
         }
         public String getFirstname(){
             return firstname;
         }
         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());
   }
}

235 综合练习2 对象数组

public class Account{
      private double balance;
      public Account(double init_balance){
          this.balance=init_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("余额不足");
        }
    }

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

public class Bank{
        private Customer[] customers;//存放多个客户的数组
        private int numberOfCustomers;//记录客户的个数
        public Bank(){
        }
        //添加客户
        public void addCustomer(String f,String l){
            Customer cust=new Customer(f,l);
            customers[numberOfCustomers]=cust;
            numberOfCustomers++;
           //customers[numberOfCustomers++]=cust;
        }
        //获取客户的个数
        public int getNumOfCustomers(){
             return getNumOfCustomers;
        }
        //获取指定位置上的客户
        public Customer getCustomer(int index){
                 if(index>=0&&index<numberOfCustomers){
                      return customers[index];
        }
        return null;
}


public class BankTest{
        public static void main(String[] args){
              Bank bank=new Bank();
              bank.addCustomer("Jane","Smith");
              bank.getCustomer(0).setAccount(new Account(2000));
              bank.getCustomer(0).getAccount().withdraw(500);
              double balance=bank.getCustomer(0).getAccount.getBalance();
              System.out.println("客户："+bank.getCustomer(0).getFirstName()+"的账户余额 
              为；"+balance);
              System.out.println("**********");
              bank.addCustomer("万里","杨");
              System.out.println("银行客户的个数为："+bank.getNumOfCustomers());
}
}

236 package关键字的使用

一，package关键字的使用

1.为了更好的实现项目中类的管理，提供包的概念

2.使用package声明类或接口所属的包，声明在源文件的首行

3.包，属于标志符，遵循标志符的命名规则，规范，见名知意

4.每"."一次,就代表一层文件目录

补充：同一个包下，不能命名同名的接口，类

不同的包下，可以命令同名的接口，类

1.java.lang----包含一些 Java 语言的核心类，如 String、Math、Integer、System 和 Thread，提供常用功能
2.java.net----包含执行与网络相关的操作的类和接口。
3.java.io----包含能提供多种输入/输出功能的类。
4.java.util----包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数。
5.java.text----包含了一些 java 格式化相关的类
6.java.sql----包含了 java 进行 JDBC 数据库编程的相关类/接口
7.java.awt----包含了构成抽象窗口工具集（abstractwindowtoolkits）的多个类，这些类被用来构建和管理应用程序的图形用户界面(GUI)。B/S C/S

237 MVC设计模式的理解

MVC 是常用的设计模式之一，将整个程序分为三个层次：视图模型层，控制器层，数据模型层。这种将程序输入输出、数据处理，以及数据的展示分离开来的设计模式使程序结构变的灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

尚硅谷java零基础入门从221p开始的笔记_开发语言_03

尚硅谷java零基础入门从221p开始的笔记_后端_04

238 import关键字的使用

import java.util.*;

import account2.Bank;

/*
 * 二、import关键字的使用
 * import:导入
 * 1.在源文件中显式的使用import结构导入指定包下的类、接口
 * 2.声明在包的声明和类的声明之间
 * 3.如果需要导入多个结构，则并列写出即可
 * 4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
 * 5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
 * 6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
 * 7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
 * 8.import static组合的使用：调用指定类或接口下的静态的属性或方法.
 * 
 */
public class PackageImportTest {

  public static void main(String[] args) {
    String info = Arrays.toString(new int[]{1,2,3});
    
    Bank bank = new Bank();
    
    ArrayList list = new ArrayList();
    HashMap map = new HashMap();
    
    Scanner s = null; 
    
    System.out.println("hello");
    
    UserTest us = new UserTest();
    
  }
}

标签：221p,java,String,int,age,void,硅谷,public,name
From： https://blog.51cto.com/u_15638336/5835751