Java封装(修饰符+包+内部类)

#封装

###修饰符

访问修饰符可以用来修饰属性和方法的访问范围。

访问范围

如图,代表了不同的访问修饰符的访问范围,比如private修饰的属性或者方法,只能在本类中访问或者使用。默认是什么修饰符都不加,默认在当前类中和同一包下都可以访问和使用。

我们可以举一个例子,比如 money,如果我们用private修饰代表着这是私有的,只能我自己可以使用。如果是protected代表着我可以使用,和我有关系的人,比如儿子也可以用。如果是public就代表了所有人都可以使用。

  • private-----本类
  • 默认--------本类,同包
  • protected–本类,同包,子类
  • public-------本类,同包,子类,其它

如果没有在属性前面添加任何修饰符,我们通过创建对象就可以直接对属性值进行修改,没有体现封装的特性。这在许多程序设计中都是不安全的,所以我们需要利用封装,来改进我们的代码。

首先我们的类里要将属性前添加private修饰符。然后定义getter和setter方法。

package encapsulation;

public class People{

//属性(成员变量)有什么,前面添加了访问修饰符private

//变成了私有属性,必须通过方法调用

    private double height;     //身高

//属性已经封装好了,如果用户需要调用属性

//必须用getter和setter方法进行调用

//getter和setter方法需要程序员自己定义

    public double getHeight(){    
    //getter 方法命名是get关键字加属性名(属性名首字母大写)
    //getter 方法一般是为了得到属性值
        return height;
    }

//同理设置我们的setter方法

//setter 方法命名是set关键字加属性名(首字母大写)

//setter 方法一般是给属性值赋值,所以有一个参数

    public void setHeight(double newHeight){
        height = newHeight;
    }
}

然后在我们的 main 函数里的对象,不能再直接调用属性了,只能通过getter和setter方法进行调用。

package encapsulation;

public class LiLei {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        People LiLei = new People();    //创建了一个People对象LiLei

        //利用setter方法为属性赋值
        LiLei.setHeight(170.0);

        //利用getter方法取属性值
        System.out.println("LiLei的身高是"+LiLei.getHeight());
    }
}

###二、包

有时候在封装的时候会遇到这样的问题,就是我们所写程序的类名可能是重复的。这时候我们就可以用包的概念来解决我们的问题。

包的作用就是管理Java文件,解决同名文件冲突。这和我们生活当中的管理相类似。我们的衣柜是不是有不同的隔断和抽屉,我们将衣服分门别类地放好,是不是有利于我们管理。

想必大家在以前就学习过了如何定义一个包,我们使用package关键字,加上我们的包名。

定义包语法:

package 包名
//注意:必须放在源程序的第一行,包名可用"."号隔开
例如:

//我们在定义文件夹的时候利用"/"来区分层次

//包中我们用"."来分层

package encapsulation.Java

比如我们在游戏里会用到音乐类,在电影里我们也会用到音乐类,但是他们的类又不相同,我们就可以利用包进行区分。

不仅是我们这样利用包名来区分类,系统也是这样做的。

Java系统中的包

	java.(功能).(类)
	java.lang.(类)  包含java语言基础的类
	java.util.(类)  包含语言中各种工具类
	java.io.(类) 包含输入、输出相关的类

那我们怎么在不同包中使用另一个文件中的类呢?这时候就需要用到import关键字。比如我们要导入实验楼下People这个类。import com.shiyanlou.Peole,同时如果import com.shiyanlou.*这是将包下的所有文件都导入进来。

** 这里要注意一点,包的命名规范是全小写字母拼写。**

###三、Java 中的 this 关键字

写代码的过程中常常会用到this关键字,this关键字代表当前对象。使用this.属性操作当前对象的属性,this.方法调用当前对象的方法。

当我们封装对象属性的时候,经常会使用this关键字。

如果用private修饰的属性,我们利用对象访问的时候,必须定义getter和setter方法,(Eclipse中可以自动帮我们定义)

1、首先在菜单栏里点击Source也可以在左侧右击选择Source

创建getter和setter方法

2、选择Grenerate Getters and Setters

创建getter和setter方法

3、系统会自动帮我们检测需要创建getter和setter方法的属性,我们根据需要勾选就行了。

当系统帮我们创建好了getter和setter方法后,我们会发现系统创建的方法中参数名和我们的属性名一样。为了区分参数名和我们的属性名,我们在属性名前面添加了this关键字。

###四、Java 中的内部类

问:什么是内部类呢?

	答:内部类( Inner Class )就是定义在另外一个类里面的类。与之对应,包含内部类的类被称为外部类。

问:那为什么要将一个类定义在另一个类里面呢?清清爽爽的独立的一个类多好啊!!

	答:内部类的主要作用如下:

	1. 内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
	2.  内部类的方法可以***直接访问外部类的所有数据,包括私有的数据
	3.  内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便

问:内部类有几种呢?

	答:内部类可分为以下几种:

	   成员内部类
	   静态内部类
	   方法内部类
	   匿名内部类

通过代码学习一下内部类


package encapsulation;

//外部类People

public class People {

    private String name = "LiLei";         //外部类的私有属性
    //内部类Student
    public class Student {

        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的name:" + name);
            System.out.println("访问内部类中的ID:" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        People a = new People();     //创建外部类对象,对象名为a
        Student b = a.new Student(); //使用外部类对象创建内部类对象,对象名为b
        b.stuInfo();   //调用内部对象的suInfo方法
    }
}

由此,我们可以知道,成员内部类的使用方法:

Student 类相当于 People 类的一个成员变量,所以 Student 类可以使用任意访问修饰符

Student 类在 People 类里,所以访问范围在类里的所有方法均可以访问 People 的属性(即内部类里可以直接访问外部类的方法和属性,反之不行)

定义成员内部类后,必须使用外部类对象来创建内部类对象,即 内部类 对象名 = 外部类对象.new 内部类();

如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字

静态内部类:

package encapsulation;

**//外部类People**

public class People {

    private String name = "LiLei";         //外部类的私有属性

**/*外部类的静态变量。

*Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有,而不是某个对象所有,即被类的所有对

*象所共享。静态成员可以使用类名直接访问,也可以使用对象名进行访问。

*/

    static String ID = "510xxx199X0724XXXX"; 

    //静态内部类Student
    public static class Student {
        String ID = "20151234";               //内部类的成员属性
        //内部类的方法
        public void stuInfo(){
            System.out.println("访问外部类中的ID:" + People.ID);
            System.out.println("访问内部类中的ID:" + ID);
        }
    }

    //测试成员内部类
    public static void main(String[] args) {
        Student b = new Student();   //直接创建内部类对象,对象名为b
        b.stuInfo();                 //调用内部对象的suInfo方法
    }
}

静态内部类是 static 修饰的内部类,这种内部类的特点是:

静态内部类不能直接访问外部类的非静态成员,但可以通过 new 外部类().成员 的方式访问

如果外部类的静态成员与内部类的成员名称相同,可通过类名.静态成员访问外部类的静态成员

如果外部类的静态成员与内部类的成员名称不相同,则可通过成员名直接调用外部类的静态成员

创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名= new 内部类()

方法内部类

方法内部类就是定义在外部类的方法中的内部类,方法内部类只在该方法的内部可见,即只在该方法内可以使用。

例如:


package encapsulation;

//外部类People

public class People {
    
    //外部类中的方法
    public void peopleInfo() {
        final String sex = "man";  //外部类方法中的常量
        class Student {
            String ID = "20151234"; //内部类中的常量
            public void print() {
                System.out.println("访问外部类的方法中的常量sex:" + sex);
                System.out.println("访问内部类中的变量ID:" + ID);
            }
        }
        Student a = new Student();  //创建方法内部类的对象
        a.print();//调用内部类的方法
    }
    //测试方法内部类
    public static void main(String[] args) {
        People b = new People(); //创建外部类的对象
        b.peopleInfo();  //调用外部类的方法
    }
}

运行结果:

	访问外部类的方法中的常量sex:man
	访问内部类中的变量ID:20151234

###部分参考来源:
[实验楼](http://www.shiyanlou.com/register?inviter=NTY0MzE5MTU5NjYw)
##注:如有雷同,纯属意外!如有侵权,本人立即删除

你可能感兴趣的:(专业课类笔记)