封装

发表于 | 更新于: | 分类于 | 阅读量
字数统计: 1,422 | 阅读时长 ≈ 6

封装是一种思想。

  • 隐藏内部细节
  • 提供使用方法

package

  • 包是可以理解为命名空间，他能有效解决类重名问题。
  • 为了方便组织和管理，多用倒置域名来标识。

权限修饰符

一个.java文件只能有一个被public修饰的类，并且类名必须与文件名相同。如果没有public关键字，则对类的命名没有要求。

修饰类

  • 默认访问权限（包访问权限）：用来修饰类的话，表示该类只对同一个包中的其他类可见。
  • public：用来修饰类的话，表示该类对其他所有的类都可见。
  • 如果你想实现其他任何人都不能访问该类，可以通过将类的所有构造器都指定为private。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.qigou.b2cex.test;

class People {

    private String name = null;

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

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
}
1
2
3
4
5
6
7
package com.qigou.b2cex.test;

public class TestExcel{
     public static void main(String[] args) throws Exception {
         System.out.println(new People("BBDog").getName());
     }
}

输出结果：

1
BBDog

将People的包名改为test1后

默认访问权限权限

修饰方法和变量

作用域 当前类 同包下 子孙 所有类
public √ √ √ √
protected √ √ √ ×
默认 √ √ × ×
private √ × × × 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package com.qigou.b2cex.test;

public class People {

    private String name = null;

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

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
}
1
2
3
4
5
6
7
8
package com.qigou.b2cex.test;

public class TestExcel{
     public static void main(String[] args) throws Exception {
       People people = new People("BBDog");
       System.out.println(people.getName());
     }
}

变更getName()的权限,每次初始化包名。

  • public

    正常输出： BBDog

    不同包下输出：BBDog

  • 默认

    同包下正常输出： BBDog

    不同包下：

    不同包默认权限方法

  • protected

    同包下正常输出： BBDog

    不同包下：

    不同包protected

    创建Kids类继承People

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    package com.qigou.b2cex.test;

    import com.qigou.b2cex.test1.People;
    public class Kids extends People {

        public Kids(String name){
            super(name);
        }

        public String toString() {
            return getName();
        }
    }

    子类可以使用protected修饰的方法

  • private

    protectedChildern

getting&setting

getting和setting是封装思想的核心。

  1. 修改属性可见性限制对属性的访问
  2. 增加赋值取值方法，方法可见。
  3. 在赋值取值方法中增加控制条件。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
pubilc class People{
    private int age;
    
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        if(age > 0){
            this.age = age; 
        }else{
            System.out.prinln("年龄不能为负数");
        }
       
    }
}

构造方法

没有新增构造方法的时候，每个类都有个默认的构造方法；

通过getting&setting，增加了对数据的统一控制，维护性强。但是如果每次赋值都单独调用一个setting方法会很麻烦。

可以通过重写构造方法来实现对类对象的赋值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
pubilc class People{
    private int age;
    private String lang;
    public People(int age,String lang){
        if(age > 0){
            this.age = age;
        }
        this.lang = lang;
    }
    
    
    public int getAge(){
        return age;
    }
    public void setAge(int age){
        if(age > 0){
            this.age = age; 
        }else{
            System.out.prinln("年龄不能为负数");
        }
       
    }
}
1
2
3
4
5
public class TestExcel{
    public static void main(String[] args){
        People people = new People(100,"Chinese");
    }
}

内部类

内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。

内部类和普通类基本没有区别，只是在内部类调用外部类属性时有特殊之处。

内部类的主要作用如下：

  1. 内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类

  2. 内部类的方法可以直接访问外部类的所有数据，包括私有的数据

内部类可以分为：

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

成员内部类

  • 内部类对象不能直接new 出来，内部类 对象名 = 外部类对象.new 内部类();

  • 编辑java文件后，产生两个.class文件:外部类.class,外部类$内部类.class

  • 外部类不能直接使用内部类的属性和方法（需要创建内部类对象，通过对象调用）
  • 内部类可以直接使用内部类的所有属性和方法(不受权限控制符影响)（同名时需要在属性或者方法前面加外部类.this.）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Hello{
    
	private String str = "123";

    class World {
        String str = "456";
        public void test() {
            System.out.println("内部类属性：" + str);
            System.out.println("外部类属性：" + Hello.this.str);
            Hello.this.test()
        }
    }

    private void test(){
        System.out.println("外部类方法被内部调用");
    }
    
	public static void main(String[] args) {
		Hello h = new Hello(); 
		World w = h.new World();
		w.test();
	}
}

静态内部类

静态内部类和普通内部类相同，区别在于，

  1. 只能调用外部类的静态属性和方法外部类.属性，外部类.方法()
  2. 想要调用外部类非静态属性和方法需要使用 new 外部类().属性/方法()
  3. 内部类对象可以通过直接new 获得

方法内部类

方法内部类只能供方法使用，对外不可见。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Hello{

    private String str = "123";

    private  void testOUT(){
        System.out.println("外部类方法被内部调用");
        class World {
            String str = "456";
            void test() {
                System.out.println("内部类属性：" + str);
                System.out.println("外部类属性：" + new Hello().str);
            }
        }
        World w = new World();
        w.test();
    }

    public static void main(String[] args) {
     Hello h = new Hello();
     h.testOUT();
    }
}

匿名内部类