java 封装jar包 java.封装

java有三大特性：封装，继承，多态。我们首先来讲封装，那么什么是封装呢？

一：概念

     将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

二：为什么要用封装

     a：只能通过规定的方法访问数据

     b：隐藏类的实例细节，方便修改和实现。

三：封装的实现步骤

      1：修改属性的可见性 -->设为private

      2：创建getter/setter方法 -->用于属性的读写

      3：在getter/setter方法中加入属性控制语句 -->对属性值的合法性进行判断 （可选）

public class Telphone {
	private float cpu;
	private float screen;
	private float mem;
	
	public float getCpu() {
		return cpu;
	}
	public void setCpu(float newCpu) {
		this.cpu = newCpu;
	}
	public float getScreen() {
		return screen;
	}
	public void setScreen(float newScreen) {
		this.screen = newScreen;
	}
	public float getMem() {
		return mem;
	}
	public void setMem(float newMem) {
		this.mem = newMem;
	}
}

public class InitTelphone {

	public static void main(String[] args) {
		Telphone phone=new Telphone();
		phone.setCpu(2.0f);
		phone.setMem(64.0f);
		phone.setScreen(1.4f);
		System.out.println("CPU:"+phone.getCpu());
		System.out.println("Memory:"+phone.getMem());
		System.out.println("Screen:"+phone.getScreen());
	}
}

  运行结果为：

   

四： 访问修饰符   

访问修饰符	本类	同包	子类	其他
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

五：内部类

     A：概念

         就是定义在另外一个类里面的类。内部类有一下作用：

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

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

     B：内部类可以分为：成员内部类，静态内部类，方法内部类，匿名内部类。

           1：成员内部类

               注意：1):不可以直接使用内部类的成员和方法，要通过内部类的对对象来访问其成员变量。

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

//外部类HelloWorld
public class HelloWorld{
    //外部类的私有属性name
    private String name = "swpu";
    //外部类的成员属性
    int age = 20;
	//成员内部类Inner
	public class Inner {
		String name = "swpu";
                //内部类中的方法
		public void show() { 
			System.out.println("外部类中的name：" +HelloWorld.this.name);//跟内部类重名，所以需要this关键字
			System.out.println("内部类中的name：" + name);
			System.out.println("外部类中的age：" + age);
		}
	}
	//测试成员内部类
	public static void main(String[] args) {
        //创建外部类的对象
	HelloWorld o = new HelloWorld (); 
        //创建内部类的对象
	Inner inn =  o.new Inner()            ;
        //调用内部类对象的show方法
	inn.show();
	}
}

     运行结果：

   

       2：静态内部类:由static修饰的内部类，特点为：

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

       2）： 如果外部类的静态成员与内部类的成员名称相同，可通过"类名.静态成员"访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过"成员名"直接调用外部类的静态成员

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

//外部类Telphone
public class Telphone{
  //外部类的静态属性name
  private static  String name = "swpu";
	//成员内部类Inner
	public static class Inner {
		String name = "swpu";
                  //内部类中的方法
		public void show() { 
			System.out.println("外部类中的name：" +Telphone.name);
			System.out.println("内部类中的name：" + name);
		}
	}
	//测试成员内部类
	public static void main(String[] args) {
        //创建内部类的对象
	Inner inn =  new Inner()            ;
        //调用内部类对象的show方法
	inn.show();
	}
}

   运行结果为：

   

   

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

//外部类
public class HelloWorld {
    private String name = "swpu";
    // 外部类中的show方法
    public void show() { 
		// 定义方法内部类
		class MInner {
			int score = 83;
			public int getScore() {
				return score + 10;
			}
		}
	// 创建方法内部类的对象
        MInner mi=new MInner();
        
        // 调用内部类的方法
	int newScore=mi.getScore();
	System.out.println("姓名：" + name + "\n加分后的成绩：" + newScore);
	}
	// 测试方法内部类
	public static void main(String[] args) {
		// 创建外部类的对象
        HelloWorld mo =new HelloWorld();
        // 调用外部类的方法
		mo.show();
	}
}