每日一学Java篇

今天继续学习Java面向对象的内容，一下素材均来自B站尚硅谷。

面向对象特征之一：封装和隐藏

一、问题的引入：

        当我们创建一个类的对象以后，我们可以通过”对象.属性“的方式，对对象的属性进行赋值。这里，赋值操作要受到属性数据类型和存储范围的制约。除此之外，没有其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制的条件的添加（比如：setLegs）。同时，我们需要避免用户再使用”对象.属性“的方式对属性进行赋值。则需要将属性声明为私有的（private）- - >此时，针对于属性就体现了封装性。

二、封装性的体现：

我们将类的属性xxx私有化（private）同时，提供公共的（public）方法来获取（getxxx）和设置（setxxx）此属性的值。

        拓展：封装性的体现：1.如上 2.不对外暴露的私有的方法 3.单例模式 . . .

public class AnimalTest {
    public static void main(String[] args){
        Animal a = new Animal();
        a.name = "大黄";
//        a.age = 1;
//        a.legs = 4;
//        a.show();

        a.setLegs(-6);
        a.show();
    }
}

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 aetAge(){
        return age;
    }
    public void setAge(int a){
        age = a;
    }
}

三、封装性的体现，需要权限修饰符来配合：

        1.Java规定的4种权限：（从小到大排列）：private、缺省、protected、public

         2. 4种权限可以用来修饰类及类的内部结构：属性、方法、构造器、内部类

        3.具体的，4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类

                修饰符的话，只能使用：缺省、public

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

public class OrderTest {
    public static void main(String[] args){
        Order order = new Order();
        order.orderPublic = 1;
        order.orderDefault = 2;
        //'orderPrivate' 在 'Order' 中具有 private 访问权限
//        order. orderPrivate= 3;

    }
}

 总结封装性：Java提供了4种权限修饰符来修饰类及类的内部结构，体现了类及类的内部结构在杯调用时的可见性的大小。

封装性练习：

        创建程序，在其中定义两个类：Person和PersonTest类。定义如下：

        用setAge()设置人的合法年龄（0~130），用getAge()返回人的年龄。

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

public class personTest  {
    public static void main(String[] args){
        Person p1 = new Person();
        p1.setAge(12);

        System.out.println("年龄为：" + p1.getAge());
    }
}

public class Person {
    private int age;

    public void setAge(int a){
        if(a < 0 || a > 130){
            throw new RuntimeException("传入的数据非法");
        }else {
            age = a;
        }
    }

    public int getAge(){
        return age;
    }
}

类的结构之三：构造器（或构造方法、constructor）的使用

一、构造器的作用：

        1.创建对象。

        2.初始化对象的属性。

二、说明：

        1.如果没有显式的定义类的构造器的话，则系统默认提供一个空参的构造器。

        2.定义构造器的格式：权限修饰符 类名(形参列表){}。

        3.一个类中定义的多个构造器，彼此构成重载。

        4.一旦我们显式的定义了类的构造器之后，系统就不在提供默认的空参构造器。

        5.一个类中，至少会有一个构造器。

public class PeronTest {
    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("人可以学习");
    }
}

构造器的练习：

练习一、

        1.在前面定义的Person类中添加构造器，利用构造器设置所有人的age属性初始值都为18。

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

练习二、

        编写两个类，TriAngle和TriAngleTest，其中TriAngle类中声明私有的低边长base和高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());
    }
}

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

}

 属性赋值的先后顺序：

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

 总结：今天学习了封装性的引入、封装性的体现、四种权限修饰符的理解、四种权限修饰符的测试、封装性练习：基本使用、构造器的基本理解、构造器使用的细节说明、构造器的练习：基本使用、总结属性赋值的过程。

每日计划：继续学习Java面向对象的内容。