Java学习（十一）——封装

一.面向对象的三大特性：

封装、继承和多态。

1.封装：

封装示例代码：

package com.classDemo;
//定义类级名称classDemo
public class classDemo {
	//定义类的属性
	private int age=18;
	String sex;
	String name;
	//定义类的方法
	//定义获取内部变量的方法
	public int getAge() {
		
		System.out.println("原始年龄是"+age);
		return age;
	}
	//定义更改内部变量的方法
	public void setAge(int newAge) {
		age=newAge;
	}
	
	void study(){
		System.out.println("不要打扰我学习！");
	}
	void sleep() {
		System.out.println(age+","+sex+","+name+","+"不要打扰我睡觉！");
	}

}

package com.classDemo;

public class humanClassDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		classDemo human=new classDemo();
		//给变量赋值
		//通过封装的方法获取内部变量的值：
		human.getAge();
		//通过封装的方法更改内部变量的值：
		human.setAge(20);
		human.sex="male";
		human.name="Geroge";
		human.study();
		human.sleep();

	}

}

运行结果：

2.包的使用：

3.访问修饰符：

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

4.this关键字：

示例代码：

	public void setAge(int newAge) {
		this.age=newAge;
	}

5.内部类：

内部类就是在类中再定义的类，包含内部类的类称为外部类。

示例代码：

package com.innerClass;

public class innerClass {
	public class Inner{
		//定义内部类Inner
		public void showMessage() {
			System.out.println("我是一个内部类！");
		}
	}
	public static void main(String args[]) {
		innerClass innerclass=new innerClass();//创建外部类对象
		Inner message=innerclass.new Inner();//创建内部类对象
		message.showMessage();//调用内部类方法
	}
	

}

6.成员内部类：

package com.innerClassDemo;

public class innerClassDemo {//外部类
	private int a=3;
	public class Inner{//内部类
		int b=2;
		public void test() {//定义内部类的方法
			System.out.println("外部类变量为"+a);
			System.out.println("内部类变量为"+b);
			}
	}
	public static void main(String args[]) {
		innerClassDemo o=new innerClassDemo();//实例化外部类
		Inner i=o.new Inner();//实例化内部类
		i.test();
	}
}

1）、 Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

2）、 Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据，而不受访问控制符的影响，如直接访问 Outer 类中的私有属性a

3）、 定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去 new 一个内部类对象，即：内部类 对象名 = 外部类对象.new 内部类( );

4).外部类变量和内部类变量名称相同时，可用外部类名.this.变量名来访问，如out.this.a。

静态内部类是 static 修饰的内部类，这种内部类的特点是：

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

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

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

package com.SInnerclass;

public class SInnerclassDemo {
	private static int a=77;//外部类中的a静态变量
	int b=99;
	public static class SInnerclass{
		int a=55;//内部类中的a静态变量
		public void show() {
			System.out.println("外部类的静态变量a为："+SInnerclassDemo.a);//访问外部类的a变量
			
			System.out.println("内部类的变量a为："+a);//访问内部类的a变量
		}
	}
	public static void main(String args[]) {
		SInnerclass si=new SInnerclass();
		si.show();
		SInnerclassDemo SI=new SInnerclassDemo();
		System.out.println("外部类的变量b为："+SI.b);//无法访问外部类的非静态变量，但是可以通过new对象的方法访问。
	}

}