JAVA-4.1-封装、private、this、标准的java描述类的写法

最新推荐文章于 2022-09-12 22:12:37 发布

元_帅

最新推荐文章于 2022-09-12 22:12:37 发布

阅读量984

点赞数 2

分类专栏： JAVA学习笔记文章标签： java 对象

本文链接：https://blog.csdn.net/qq_30718113/article/details/69258381

版权

JAVA学习笔记专栏收录该内容

41 篇文章 4 订阅

订阅专栏

一：封装
　　1.1封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
　　　　封装的好处：
　　　　　　A:提高了代码的复用性
　　　　　　B:提高安全性。
　　　　体现：将不需要对外提供的内容都隐藏起来。
　　　　做法：把属性隐藏，提供公共方法对其访问。
　　　　
举例：新建一个学生类，如下：

package com.edu_01;
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void makePlane(){
        System.out.println("学生会造飞机");
    }

    public void eat(){
        System.out.println("饿了就上饿了吗");
    }

}

同包下建立Test类，如下：

package com.edu_01;
public class Test {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();

        //给学生对象的姓名和年龄赋值
        s.name = "李四";
        s.age = -10;
        //打印学生的成员变量
        System.out.println(s.name+"  "+s.age);
        //李四   -10
    }
//现在我们可以给age赋值，但是赋予负数值居然也通过了。这是不满足实际需求的。
}

我们应该对不满足需求的数据给与判断。对学生类修改如下：

package com.edu_01;
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void makePlane(){
        System.out.println("学生会造飞机");
    }

    public void eat(){
        System.out.println("饿了就上饿了吗");
    }

    //提供一个检测年龄的方法
    public void checkAge(int a){
        if (a>100||a<0) {
            System.out.println("您填写的年龄不符合规则");
        }else {
            age = a;
        }
    }
}

并修改Test，如下：

package com.edu_01;
public class Test {
    public static void main(String[] args) {
        //创建学生对象
        Student s = new Student();

        //给学生对象的姓名和年龄赋值
        s.name = "李四";
        //s.age = -10;不用这种方式赋值，但是依旧可以利用此方式赋值
        //使用我们刚刚创建的检测年龄的方法给学生年龄赋值
        s.checkAge(-20);

        //打印学生的成员变量
        System.out.println(s.name+"  "+s.age);
    }
}

　　综上所述，虽然我们已经通过一个方法做出了数据不正常的判断，但是我们还是可以通过对象直接访问成员变量。那么，为了让使用者使用方法来给成员变量赋值，就不能允许它们直接去访问成员变量。那么我们该怎么办呢?为了解决这种情况，java就提供了一个修饰符关键字：private
　　　　private：私有的意思。
　　　　　　　　可以修饰成员变量和成员方法。
　　　　　特点：被private修饰的内容，只能在本类中访问。
　　　　　
　　1.2封装加入private后的标准代码：
　　　　A:把成员变量private修饰
　　　　B:针对每一个成员变量给出getXxx()和setXxx()（注意首字母大写）
　　　　注意：这里的xxx其实是成员变量名称。

二：this关键字详解
　　局部变量如果有一个变量和成员变量名称一致，那么优先使用的是局部变量。即就近原则。这样的话，就造成了局部变量隐藏了成员变量。如何解决呢?为了解决这种情况，java就提供了一个代表本类对象的关键字：this。
　　this这个关键字指代本类中的一个对象，但是具体指代本类中的哪个对象呢？– 谁调用我我指代谁。

三：构造方法
　　3.1构造方法：
　　　　作用：给对象的数据进行初始化
　　　　格式特点：
　　　　　　A:方法名和类名相同。
　　　　　　　　public void Student() {}
　　　　　　B:没有返回值类型。
　　　　　　　　修饰符返回值类型方法名(…) {…}
　　　　　　C:没有返回值。
　　　　　　　　没有用return带明确的值回来。
　　　　　　　　return;
　　3.2构造方法注意事项
　　　　A:如果你不提供构造方法，系统会给出默认无参构造方法
　　　　B:如果你提供了构造方法，系统将不再提供默认无参构造方法
　　　　　　这个时候怎么办呢?
　　　　　　　　a:使用自己给的带参构造。
　　　　　　　　b:要么自己再提供一个无参构造
　　　　　　　　　　建议：永远自己给出无参构造方法。
　　　　　　　　ｃ:构造方法也是可以重载的。
　　3.3给成员变量赋值：
　　　　A:通过setXxx()方法
　　　　B:通过带参构造方法

四：成员方法：去掉static的方法。
　　这里写图片描述

五：标准代码的写法：
例如：
　　这里写图片描述

package com.edu_04;
/**
 * 
        一个标准的java描述类：
        1.私有化成员变量
        2.为私有化的成员变量提供set/get方法
        3.提供有参数和无参数的构造方法
        4.还需要写一个功能性的方法
 */
public class Phone {
    //提供私有化的成员变量
    private String brand;
    private int price;
    private String color;

    //为私有化的成员变量提供set/get方法
    public void setBrand(String brand){
        this.brand = brand;
    }
    public String getBrand(){
        return brand;
    }

    public void setPrice(int price){
        this.price = price;
    }
    public int getPrice(){
        return price;
    }

    public void setColor(String color){
        this.color = color;
    }
    public String getColor(){
        return color;
    }

    //提供有参数和无参数的构造方法
    public Phone(){}

    public Phone(String brand,int price,String color){
        this.brand = brand;
        this.price = price;
        this.color = color;
    }

    //提供功能性的方法
    public void call(){
        System.out.println("手机可以打电话");
    }
    public void show(){
    //show方法打印三个成员变量
        System.out.println(brand+"  "+price+"  "+color);
    }   
}

新建一个测试类：

package com.edu_04;
public class Test {
    public static void main(String[] args) {
        //创建一个手机对象，使用set方法给对象赋值（无参构造+set方法）
        Phone p = new Phone();
        p.setBrand("华为");
        p.setColor("黑色");
        p.setPrice(2000);
        System.out.println(p.getBrand()+"  "+p.getColor()+"  "+p.getPrice());
        System.out.println("-----------------------------");
        //使用有参构造创建对象并且给对象赋值
        Phone p2 = new Phone("苹果", 5000, "土豪金");
        System.out.println(p2.getBrand()+"  "+p2.getColor()+"  "+p2.getPrice());
        System.out.println("-----------------------------");
        p2.call();
        p2. show(); 
    }
}

输出结果：
//  华为  黑色  2000
//  -----------------------------
//  苹果  土豪金  5000
//  -----------------------------
//  手机可以打电话
//  苹果  5000  土豪金

四：static关键字
　　6.1为了体现共用的数据，java提供了一个关键字：static。
　　　　static:
　　　　　　作用：可以修饰成员变量和成员方法
　　　　　　特点：
　　　　　　　　A:随着类的加载而加载
　　　　　　　　B:优先于对象存在
　　　　　　　　C:被类的所有对象共享–也是我们判断该不该使用静态修饰一个数据的依据。
　　　　　　　　D:可以通过类名调用
　　　　　　　　　　静态变量：类变量
　　　　　　　　　　非静态变量：实例变量，对象变量
　　　　　　　　　　
　　　　　　　　　　　　非静态的：创建对象访问
　　　　　　　　　　　　静态的：可以通过类名，也可以通过对象访问。

　　６.2（写一个静态成员变量和静态成员方法进行演示）
　　　　static关键字注意事项
　　　　　　A:在静态方法中是没有this关键字的
　　　　　　　　原因：静态的内容随着类的加载而加载，this是随着对象的创建而存在，所以，static中不能有this。
　　　　　　B:静态方法只能访问静态的成员变量和静态的成员方法。即静态方法只能访问静态的成员。
举例说明static用法，新建学生类如下：

package com.edu_08;
public class Student {
    String name;
    int age;
    static String className = "java001";//静态的成员变量，是被所有对象所共享的东西

    //创建几个构造方法
    public Student(){}

    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }

    public Student(String name,int age,String className){
        this.name = name;
        this.age = age;
        this.className = className;
    }

    //创建一个静态的成员方法
    public static void show(){
        System.out.println("student的静态show方法");
    }
}

新建Test类进行测试，如下：

package com.edu_08;
public class Test {
    public static void main(String[] args) {
        //使用无参数的构造方法创建一个对象
        Student s = new Student();
        s.name = "张三";
        s.age = 50;
        System.out.println(s.name+"  "+s.age+"  "+s.className);//张三  50  java001

        System.out.println("-----------------------------");
        //使用带有两个参数的构造方法创建两个对象
        Student s2 = new Student("李四", 37);
        Student s3 = new Student("王五", 50);
        System.out.println(s2.name+"  "+s2.age+"  "+s2.className);//李四  37  java001
        System.out.println(s3.name+"  "+s3.age+"  "+s3.className);//王五  50  java001

        System.out.println("-------------------------------");
        //使用三个参数的构造方法创建一个对象
        Student s4 = new Student("赵六", 50, "java002");
        System.out.println(s4.name+"  "+s4.age+"  "+s4.className);//赵六  50  java002
        System.out.println(s2.name+"  "+s2.age+"  "+s2.className);//李四  37  java002
        System.out.println(s3.name+"  "+s3.age+"  "+s3.className);//王五  50  java002

        System.out.println("---------------------------------");
        //通过类名直接调用静态的成员变量和静态的成员方法
        System.out.println(Student.className);
        Student.show();
    }
}
//输出结果为：
//张三  50  java001
//-----------------------------
//李四  37  java001
//王五  50  java001
//-------------------------------
//赵六  50  java002
//李四  37  java002
//王五  50  java002
//---------------------------------
//java002
//student的静态show方法