package com.atguigu.java;/* * 面向对象的特征一：封装与隐藏 3W:what? why? how? * 一、问题的引入： * 当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到 * 属性的数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值 * 加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()） * 同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private). * -->此时，针对于属性就体现了封装性。 * * 二、封装性的体现： * 我们将类的属性xxx私有化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值 * * 拓展：封装性的体现：① 如上 ② 不对外暴露的私有的方法 ③ 单例模式 ... * * * 三、封装性的体现，需要权限修饰符来配合。 * 1.Java规定的4种权限（从小到大排列）：private、缺省、protected 、public * 2.4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类 * 3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类 * 修饰类的话，只能使用：缺省、public * * 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现类及类的内部结构在被调用时的可见性的大小。 * */public class AnimalTest { public static void main(String[] args) { Animal a = new Animal(); a.name = "大黄";// a.age = 1;// a.legs = 4;//The field Animal.legs is not visible a.show(); // a.legs = -4;// a.setLegs(6); a.setLegs(-6); // a.legs = -4;//The field Animal.legs is not visible a.show(); System.out.println(a.name); }}class Animal{ String name; private int age; private int legs;//腿的个数 //对属性的设置 public void setLegs(int l){ if(l >= 0 && l % 2 == 0){ legs = l; }else{ legs = 0;// 或者抛出一个异常 } } //对属性的获取 public int getLegs(){ return legs; } public void eat(){ System.out.println("动物进食"); } public void show(){ System.out.println("name = " + name + ",age = " + age + ",legs = " + legs); } //提供关于属性age的get和set方法 public int getAge(){ return age; } public void setAge(int a){ age = a; } }//private class Dog{// //}
package com.atguigu.java;public class Order { private int orderPrivate; int orderDefault; public int orderPublic; private void methodPrivate(){ orderPrivate = 1; orderDefault = 2; orderPublic = 3; } void methodDefault(){ orderPrivate = 1; orderDefault = 2; orderPublic = 3; } public void methodPublic(){ orderPrivate = 1; orderDefault = 2; orderPublic = 3; } } package com.atguigu.java;public class OrderTest { public static void main(String[] args) { Order order = new Order(); order.orderDefault = 1; order.orderPublic = 2; //出了Order类之后，私有的结构就不可以调用了// order.orderPrivate = 3;//The field Order.orderPrivate is not visible order.methodDefault(); order.methodPublic(); //出了Order类之后，私有的结构就不可以调用了// order.methodPrivate();//The method methodPrivate() from the type Order is not visible }}
package com.atguigu.java1;import com.atguigu.java.Order;public class OrderTest { public static void main(String[] args) { Order order = new Order(); order.orderPublic = 2; // 出了Order类所属的包之后，私有的结构、缺省声明的结构就不可以调用了// order.orderDefault = 1; // order.orderPrivate = 3;//The field Order.orderPrivate is not visible order.methodPublic(); // 出了Order类所属的包之后，私有的结构、缺省声明的结构就不可以调用了// order.methodDefault(); // order.methodPrivate();//The method methodPrivate() from the type Order is not visible }}
package com.atguigu.exer;/* * 1.创建程序,在其中定义两个类：Person和PersonTest类。定义如下： * 用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。 * * 2.练习2： * 2.1. 在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。 * 2.2. 修改上题中类和构造器，增加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 setAge(int a){ if(a < 0 || a > 130){// throw new RuntimeException("传入的数据非法！"); System.out.println("传入的数据非法！"); return; } age = a; } public int getAge(){ return age; } //绝对不要这样写！！// public int doAge(int a){// age = a;// return age;// } public void setName(String n){ name = n; } public String getName(){ return name; } } package com.atguigu.exer;/* * 在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()); // p1.doAge(122); Person p2 = new Person("Tom", 21); System.out.println("name = " + p2.getName() + ",age = " + p2.getAge()); }}
package com.atguigu.java1;/* * 类的结构之三：构造器（或构造方法、constructor）的使用 * construct：建设、建造。 construction:CCB constructor:建设者 * * 一、构造器的作用： * 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("人可以学习"); } }
package com.atguigu.exer1;/* * 编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的底边长base和高height，同时声明公共方法访问私有变量。 * 此外，提供类必要的构造器。另一个类中使用这些公共方法，计算三角形的面积。 */public class TriAngle { //angle:角 angel:天使 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; } } package com.atguigu.exer1;public class TriAngleTest { public static void main(String[] args) { TriAngle t1 = new TriAngle(); t1.setBase(2.0); t1.setHeight(2.4);// t1.base = 2.5;//The field TriAngle.base is not visible// t1.height = 4.3; 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()); }}
package com.atguigu.java1;/* * 总结：属性赋值的先后顺序 * * * ① 默认初始化 * ② 显式初始化 * ③ 构造器中初始化 * * ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值 * * 以上操作的先后顺序：① - ② - ③ - ④ * */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); u1.setAge(5); 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; } }
package com.atguigu.java1;/* * 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; } }
package com.atguigu.java2;/* * 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(形参列表)"，用来调用其他的构造器 * * */public class PersonTest { public static void main(String[] args) { Person p1 = new Person(); p1.setAge(1); System.out.println(p1.getAge()); p1.eat(); System.out.println(); Person p2 = new Person("Jerry",20); System.out.println(p2.getAge()); }}class Person{ private String name; private int age; public Person(){ // this.eat(); String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)"; System.out.println(info); } public Person(String name){ this(); this.name = name; } public Person(int age){ this(); this.age = age; } public Person(String name,int age){ this(age); this.name = name; //this.age = age; //Person初始化时，需要考虑如下的1,2,3,4...(共40行代码) } public void setName(String name){ this.name = name; } public String getName(){ return this.name; } public void setAge(int age){ this.age = age; } public int getAge(){ return this.age; } public void eat(){ System.out.println("人吃饭"); this.study(); } public void study(){ System.out.println("人学习"); } }
package com.atguigu.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("先多谈谈恋爱~~"); } }}
package com.atguigu.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); } 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; } }
package com.atguigu.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("一样大"); } }}
package com.atguigu.exer3;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; } //在提款方法withdraw中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。 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); } }} package com.atguigu.exer3;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; } } package com.atguigu.exer3;/* * 写一个测试程序。（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()); }}
package com.atguigu.exer4;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("余额不足"); } }} package com.atguigu.exer4;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; } }
package com.atguigu.exer4;public class Bank { private Customer[] customers;// 存放多个客户的数组 private int numberOfCustomers;// 记录客户的个数 public Bank() { customers = new Customer[10]; } // 添加客户 public void addCustomer(String f, String l) { Customer cust = new Customer(f, l); // customers[numberOfCustomers] = cust; // numberOfCustomers++; // 或 customers[numberOfCustomers++] = cust; } // 获取客户的个数 public int getNumOfCustomers() { return numberOfCustomers; } // 获取指定位置上的客户 public Customer getCustomer(int index) { // return customers[index];//可能报异常 if (index >= 0 && index < numberOfCustomers) { return customers[index]; } return null; }}
package com.atguigu.exer4;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()); }}
package com.atguigu.java2;import java.lang.reflect.Field;import java.util.*;import com.atguigu.exer4.Account;import com.atguigu.exer4.Bank;import com.atguigu.java2.java3.Dog;import static java.lang.System.*;import static java.lang.Math.*;/* * 一、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:导入指定类或接口中的静态结构:属性或方法。 */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!"); Person p = new Person(); Account acct = new Account(1000); //全类名的方式显示 com.atguigu.exer3.Account acct1 = new com.atguigu.exer3.Account(1000,2000,0.0123); Date date = new Date(); java.sql.Date date1 = new java.sql.Date(5243523532535L); Dog dog = new Dog(); Field field = null; out.println("hello"); long num = round(123.434); }}
