【JAVA学习笔记】面向对象三大特性之“封装”

作者: Geekero | 来源:发表于2021-04-05 08:47 被阅读0次

学习自华为开发者学院陈璇老师的JAVA系列课程

一、封装

1.1 封装的目的

1.2 封装的实现（属性的隐藏，setter和getter方法的公开）

/*
* 宠物狗类
*/

public class Dog {
    //1. 隐藏属性
    private String name = "无名氏"; //昵称
    private int health = 100; //健康值，默认100，0~100之间，小于60为不健康
    private int love = 0; //亲密度
    private String strain = "聪明的拉布拉多犬"; //品种

    //添加属性的setter/getter方法,并加入属性控制语句
    public void setHealth(int health){
        if(health<0 || health>100){
            System.out.println("宠物狗的健康值只能在0~100之间！");
            this.health = 60;
            return;
        }
        this.health = health;
    }

    public int getHealth(){
        return this.health;
    }


    public void setName(String name){
        this.name = name;
    }

    public String getName(){
        return this.name;
    }

    public void setLove(int love){
        if(love<0 || love>100){
            System.out.println("宠物狗的亲密度只能在0~100之间！");
            this.love = 60;
            return;
        }
        this.love = love;
    }

    public int getLove(){
        return this.love;
    }

    public void setStrain(String strain){
        this.strain = strain;
    }

    public String getStrain(){
        return this.strain;
    }

    /*
    * 输出狗狗信息
    */
    public void print(){
        System.out.println("宠物的自白：\n我的名字叫" + this.name +
                "，健康值是" + this.health + "，和主人的亲密度是"
                 + this.love + "，我是一只" + this.strain + ". ");
    }
}

/*
* 宠物企鹅类
*/
public class Penguin {
    private String name = "无名氏"; //昵称
    private int health = 100; //健康值，默认100，0~100之间，小于60为不健康
    private int love = 0; //亲密度
    private String strain = "企鹅"; //品种
    private String sex = "Q仔";

    public void setName(String name) {
        this.name = name;
    }

    public void setHealth(int health) {
        if(health<0 || health>100){
            System.out.println("宠物狗的健康值只能在0~100之间！");
            this.health = 60;
            return;
        }
        this.health = health;
    }

    public void setLove(int love) {
        if(love<0 || love>100){
            System.out.println("宠物企鹅的亲密度只能在0~100之间！");
            this.love = 60;
            return;
        }
        this.love = love;
    }

    public void setStrain(String strain) {
        this.strain = strain;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public int getHealth() {
        return health;
    }

    public int getLove() {
        return love;
    }

    public String getStrain() {
        return strain;
    }

    public String getSex() {
        return this.sex;
    }

    /*
     * 输出狗狗信息
     */
    public void print(){
        System.out.println("宠物的自白：\n我的名字叫" + this.name +
                "，健康值是" + this.health + "，和主人的亲密度是"
                + this.love + "，我是一只" + this.strain + ". ");
    }
}

import java.util.Scanner;

public class TestPet {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("欢迎您来到宠物店！");
        System.out.print("请输入要领养宠物的名字：");
        String name = input.next();
        System.out.print("请输入要领养宠物的类型：1、狗狗；2、企鹅 ");
        int typeNo = input.nextInt();
        switch (typeNo){
            case 1:
                //创建狗狗对象
                Dog dog = new Dog();
                dog.setName(name);
                //狗狗其他属性
                dog.setHealth(-1000);
                System.out.println(dog.getHealth());

                dog.setLove(-9);

                dog.setStrain("吉娃娃");
                dog.print();
                break;
            case 2:
                //接受用户键盘录入信息
                System.out.print("请输入企鹅的性别：1、Q妹；2、Q仔  ");
                int SexId = input.nextInt();
                String sex = (SexId==1) ? "Q妹" : "Q仔";
                System.out.print("请输入企鹅的健康值：");
                int health = input.nextInt();
                System.out.print("请输入企鹅的亲密度：");
                int love = input.nextInt();

                //创建企鹅对象
                Penguin p = new Penguin();
                p.setName(name);
                p.setSex(sex);
                p.setHealth(health);
                p.setLove(love);
                p.print();
                break;

            default:
                System.out.println("暂时没有这个类型的宠物！");
                break;
        }


    }
}

1.3 包

1.4 访问权限控制

1.4.1 类的访问权限控制

类的修饰符：

public修饰符：公有访问级别
默认修饰符：包级私有访问级别

[robin@DESKTOP-POANC35 AccessControl]$ tree
.
├── AccessControl.iml
└── src
    └── cn
        └── com
            ├── oop1
            │   ├── Person.java
            │   ├── Student.java
            │   └── Test.java
            ├── oop2
            │   └── Test2.java
            └── oop3

package cn.com.oop1;

//类可以通过pubic来修饰
public class Student {
}

package cn.com.oop1;

//默认修饰符
class Person {
}

package cn.com.oop1;

public class Test {
    public static void main(String[] args) {
        //同包的类既可以访问public，也可以访问默认修饰符修饰的类
        Student s = new Student();
        Person p = new Person();
    }
}

package cn.com.oop2;
import cn.com.oop1.Student;
//import cn.com.oop1.Person;

public class Test2 {
    public static void main(String[] args) {
        //不同包的类只可以访问public，不可以访问默认修饰符修饰的类
        Student s = new Student();
        //Person p = new Person();
    }
}

1.4.2 类成员的访问权限控制

private修饰的类成员：只能本类访问
默认修饰符修饰的类成员：本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
protected修饰符修饰的类成员：本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
public修饰符修饰的类成员：都可以被访问

1.5 static修饰符

1.5.1 static变量

作用：

数据被类的所有实例共享
所有类的实例都包含一个相同的常量属性，定义为静态常量可以节省内存空间

1.5.2 static方法

1.5.3 static代码块

oop1:

Person.java

package cn.com.oop1;

//默认修饰符
class Person {
   //属性，成员变量，全局变量
   int age;
   String name;
   String email;

   //成员方法
}

Student.java

package cn.com.oop1;

//类可以通过pubic来修饰
public class Student {
    //private修饰的类成员，只能本类访问
    private int age;
    //默认修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
    String name;
    //protected修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
    protected String address;
    //public修饰符修饰的类成员,都可以被访问
    public char sex;

    private void m1(){
        System.out.println(this.age);
        System.out.println(this.name);
        System.out.println(this.address);
        System.out.println(this.sex);
    }
}

Test.java

package cn.com.oop1;

public class Test {
    public static void main(String[] args) {
        //同包的类既可以访问public，也可以访问默认修饰符修饰的类
        Student s = new Student();
        //其他类不能调用Studet类private修饰的类成员(属性、方法）
        //s.age;
        //默认修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
        System.out.println(s.name);
        //protected修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
        System.out.println(s.address);
        Person p = new Person();
        System.out.println(s.sex);
//        s.m1();

    }
}

oop2:

Test.java

package cn.com.oop2;
import cn.com.oop1.Student;
//import cn.com.oop1.Person;

public class Test2 {
    public static void main(String[] args) {
        //不同包的类只可以访问public，不可以访问默认修饰符修饰的类
        Student s = new Student();
        //s.age;
        //默认修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
        //System.out.println(s.name);
        //protected修饰符修饰的类成员,本类可以访问,同包的其他类也可以访问,但不能被其他包的其他类访问
        //System.out.println(s.address);
        //Person p = new Person();
        System.out.println(s.sex);
    }
}

oop3.staticdemo

Person.java

package cn.com.oop3.staticdemo;

//默认修饰符
class Person {
    //属性，类的普通成员变量，全局变量----->实例变量
    int age;
    String name;
    //静态变量 --> 通过类名去调用
    static String email; //还是Person的属性（成员变量）

    public void m2() {
        System.out.println("实例方法m2");
    }

    //成员方法：实例方法--->可以调用实例变量、实例方法、静态变量、静态方法
    public void m1() {
        //在实例方法中可以访问静态变量，但不能定义静态变量
        //static String email2;
        System.out.println(this.age);
        System.out.println(email);
        this.m2();
        m3();
    }

    //静态方法
    public static void m3() {
        //静态方法中不能使用this
        //System.out.println(this.age);
        //在静态方法中不能调用实例方法
        //m1();
        //在静态方法中不能调用实例变量
        //System.out.println(age);
        System.out.println("静态方法m3");
        //在静态方法中可直接访问静态变量
        System.out.println(email);
        //在静态方法中可直接访问静态方法
        m4();
    }

    public static void m4(){
        System.out.println("静态方法m4");
    }
}

StaticTest.java

package cn.com.oop3.staticdemo;

public class StaticTest {
    static int num = 100;
    static{
        num+=100;
        System.out.println(num);
    }
    static{
        num+=100;
        System.out.println(num);
    }

//    public static void main(String[] args) {
//        StaticTest st1 = new StaticTest();
//        StaticTest st2 = new StaticTest();
//        System.out.println(StaticTest.num);
//    }
}

Test.java

package cn.com.oop3.staticdemo;

public class Test {
    public static void main(String[] args) {
        StaticTest st1 = new StaticTest();
        StaticTest st2 = new StaticTest();
        System.out.println(StaticTest.num);
    }
}

TestPerson.java

package cn.com.oop3.staticdemo;

public class TestPerson {
    public static void main(String[] args) {
        //调用类的普通成员变量（属性），需要创建对象（实例），通过对象去访问---->实例变量
        Person p = new Person();
        p.age = 18;
        p.name = "张三";
        //静态变量 --> 通过类名去调用
        Person.email = "zhangsan@163.com";
        //通过实例调用实例方法
        p.m1();
        //通过类名调用静态方法
        Person.m3();
    }
}

TestVoter.java

package cn.com.oop3.staticdemo;

public class TestVoter {
    public static void main(String[] args) {
        Voter v1 = new Voter("张三");
        v1.vote();
        Voter v2 = new Voter("李四");
        v2.vote();
        Voter v3 = new Voter("王五");
        v3.vote();
        System.out.println("*****************************");
        Voter.showCount();

        for(int i = 1; i <= 97; i++){
            Voter v = new Voter("v"+i);
            v.vote();
        }

        System.out.println("*****************************");
        Voter.showCount();

        Voter v4 = new Voter("小明");
        v4.vote();

        System.out.println("*****************************");
        Voter.showCount();
    }
}

Voter.java

package cn.com.oop3.staticdemo;

/*
* 选民类
*/
public class Voter {
    //目前投票数,被所有选民实例共享
    static int count;
    //投票总数最大值,被所有选民实例共享,到100时停止投票
    static final int MAX_COUNT = 100;
    //选民名字
    private String name;

    public Voter(){}
    public Voter(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //选民投票的方法
    public void vote(){
        if(count == MAX_COUNT){
            System.out.println("投票总数达到100，无法继续投票！");
            return;
        }else{
            count++;
            System.out.println(this.name+"投票成功！当前票数为："+count);
        }
    }

    //显示当前投票总数
    public static void showCount() {
        System.out.println("当前投票总数为："+count);
    }
}

【JAVA学习笔记】面向对象三大特性之“封装”

一、封装

1.1 封装的目的

1.2 封装的实现（属性的隐藏，setter和getter方法的公开）

1.3 包

1.4 访问权限控制

1.4.1 类的访问权限控制

1.4.2 类成员的访问权限控制

1.5 static修饰符

1.5.1 static变量

1.5.2 static方法

1.5.3 static代码块

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读