Java-笔记10

 

 

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

 

 

 

 

 

 

 

转载于:https://www.cnblogs.com/LXL616/p/10877393.html