JAVA基础初探（四）JAVA封装、包的概念及使用、访问修饰符、this关键字、内部类(成员，静态，方法，匿名)

该篇博客目录

1、JAVA封装

2、JAVA中的包

3、访问修饰符

4、JAVA中this关键字

5、JAVA内部类（成员内部类，静态内部类，方法内部类，匿名内部类）

---

一、JAVA封装

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法来实现对隐藏信息的操作和访问。简单的说就是指隐藏对象的属性和实现细节，仅对外提供公共访问方式

1、封装的好处

• 只能通过规定的方法访问数据
• 隐藏类的实例细节，方便修改和实现（提高代码的复用性）
• 提高安全性

2、封装的实现步骤

• 修改属性的可见性——设为private
• 创建getter/setter方法——用于属性的读写

• 在getter/setter方法中加入属性控制语句——对属性值的合法性进行判断

  //test类
  package hhh;
  
  public class test {
      private int a;
      public int getA() {
          return a;
      }
  
      public void setA(int a) {
          this.a = a;
      }   
  }
  
  //my_hello_world类
  package hhh;
  
  public class my_hello_world {
      public static void main(String[] args) {
          // TODO Auto-generated method stub
          test obj=new test();
          obj.setA(3);
          int c=obj.getA();
          System.out.print(c);
      }
  }
  

---

二、JAVA中的包

1、包的作用（包和文件夹类似）

• 管理JAVA文件
• 解决同名文件冲突（可以用不同的包来区分相同文件名的类）

2、定义包

package 包名;

Tip:必须放在JAVA源程序的第一行，包名可以使用“.”号隔开，xxx.xxxx.xxxxx(相当于文件夹中还有文件夹)

例：

音乐类——mymusic

• 在音乐中
  com.music.mymusic

• 在电影中
  com.movie.mymusic

3、系统中的包

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

4、包的使用

a、import

可以通import关键字，在某个文件使用其他文件中的类

下面是import的demo

包目录

hhh包

package hhh;

public class test {
    public test()
    {
        System.out.println("hhh包");
    }
}

hhh.second包

package hhh.second;

public class test {
    public test()
    {
        System.out.println("hhh.second包");
    }
}

主函数（用到hhh包）

package hhh;

public class my_hello_world {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test obj=new test();
    }
}
//输出：hhh包

主函数（利用import用到hhh.second包）

package hhh;
import hhh.second.test;

public class my_hello_world {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        test obj=new test();
    }
}
//输出：hhh.second包

b、JAVA中，包的命名规范是全部小写字母拼写

c、加载某个包下所有文件

• com.hhh.*;

d、加载某个具体子包下所有文件

• com.hhh.second.*;

---

三、访问修饰符

---

四、JAVA中this关键字

this关键字代表当前类的一个对象

• this.属性————操作当前对象的属性
• this.方法————操作当前对象的方法

demo

public void setA(int a)
{
    this.a=a;
}

---

五、JAVA内部类（成员内部类，静态内部类，方法内部类，匿名内部类）

内部类指定义在某个类里面的类，所以某个类称为外部类，某个类里面的类称为内部类

1、内部类种类

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

2、内部类主要作用

• 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中其他类访问该类
• 内部类的方法可以直接访问外部类的所有数据，包括私有数据

• 内部类所实现的功能使用外部类同样可以实现，只是有时候使用内部类实现更方便

  package hhh;
  
  //外部类
  public class my_hello_world {
      public void iner() {
          System.out.println("外部类方法");
      }
      //内部类
      public class Hello{
          public void show() {
              System.out.println("内部类方法");
          }
      }
  
      public static void main(String[] args) {
          // TODO Auto-generated method stub
          //创建外部类对象
          my_hello_world obj=new my_hello_world();
          obj.iner();
  
          //创建内部类对象
          Hello obj2=obj.new Hello();
          obj2.show();
      }
  }
  

3、成员内部类

即普通内部类，以上写的就是

4、静态内部类

通过static修饰的内部类

a、特点

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

• 创建静态内部类对象时，不需要外部类对象，可以直接创建：内部类 对象名=new 内部类();

  package hhh;
  
  //外部类
  public class my_hello_world {
      private int a=1;
      static int b=2;
      //静态内部类
      public static class Hello{
          int b=4;
          public void show() {
              System.out.println("访问外部类的b"+my_hello_world.b);
              System.out.println("访问内部类的b"+b);
          }
      }
  
      public static void main(String[] args) {
          // TODO Auto-generated method stub
          //创建内部类对象
          Hello obj2=new Hello();
          obj2.show();
      }
  }
  //输出：
  //访问外部类的b2
  //访问内部类的b4
  

5、方法内部类

指内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只有该方法内可以使用

    package hhh;

    //外部类
    public class my_hello_world {
        //外部类方法
        public void show() {
            int a=1;
            //方法内部类
            class Hello{//方法内部类不能使用访问控制符和static
                int b=2;
                public void print() {
                    System.out.println("外部类方法中的变量a："+a);
                    System.out.println("内部类变量b："+b);
                }
            }
            Hello obj=new Hello();
            obj.print();
        }
        public static void main(String[] args) {
            // TODO Auto-generated method stub
            my_hello_world obj2=new my_hello_world();
            obj2.show();
        }
    }
    //输出：
    //外部类方法中的变量a：1
    //内部类变量b：2

Tip:由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问修饰符和static关键字