Java面向对象编程-权限控制,封装与内部类

权限控制

访问权限

Java中四种不同的限定词限定的成员(成员变量和成员方法),访问权限由大到小依次为:

• public(公共的) :可以被所有的类访问
• protected(受保护的) :
  1.可以被这个类本身访问
  2.被它的子类(同一个包以及不同包中的子类)访问
• 默认的/友好的 :
  1.被这个类本身访问
  2.被同一个包中的类本身访问
• private(私有的) :
  1.只能被这个类本身访问
  2.如果一个类的构造方法声明为private,则其他类不能生成该类的一个实例

权限控制(总结) :

• private(私有的) : 在类的内部访问
• 默认的/友好的 :只能在用一个包内的所有类访问
• protected(受保护的) :
  1.在同一个包中的所有类可以访问
  2.不同包中的子类也可以访问
• public(公共的) :任何地方都可以访问

csdn包中的Person类:

package csdn;//所在包

public class Person {
	//公有的
	public String name;
	//受保护的
	protected String sex;
	//默认的/友好的
	int age;
	//private(私有的)
	private String cardno;
	public Person() {}//构造函数
	public Person(String name,String sex,int age,String cardno){
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.cardno = cardno;
	}
	public void display(){//输出函数
		System.out.println("name:"+this.name+";sex:"+sex+";age="+age+"cardno:"+this.cardno);
	}
}

csdn包中的PersonTest测试类:

私有权限例子:
package csdn;

public class PersonTest {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.name = "张三";
		p1.sex = "男";
		p1.age = 18;
		//p1.cardno = "111111111111";//报错:私有成员其他类不能访问
	}
}

csdn.t1(csdn包内建立的包t1)包中PersonTest1测试类

package csdn.t1;

import csdn.Person;

public class PersonTest1 {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.name = "李四";
		//p1.sex = "男";错误(后面有单独的例子)
		//p1.age = 19;报错:默认权限只能被同一个包中的类访问
		//p1.cardno = "111111111";报错:私有成员外部不能访问,只能在类内部访问
	}
}

csdn.t1包中的PersonYellow测试类(该类继承了Person类)

package csdn.t1;

import csdn.Person;

/**
 * extends继承(这里不做详细解释,下一讲做详解)
 * PersonYellow叫做子类,Person叫做父类
 * */
public class PersonYellow extends Person{
	public void display(){
		/**
		 * sex变量为受保护的成员:
		 * 1.可以被同一个包中的所有类访问
		 * 2.可以被不同包中的子类访问
		 * 这里PersonYellow为Person的子类,所以sex可以被访问
		 * */
		this.name = "张三";
		this.sex = "男";
	}
}

这里涉及到的包和类比较多,我尽可能直白的解释,但可能很多小伙伴仍有不理解的地方,可以给我留言我予以解答.

类的封装

封装

将成员变量声明为私有的(private),在提供一个或者多个共有(public)setXX()和getXX()方法,实现对该成员变量的访问

目的

• 隐藏类的实现细节
• 让使用者只能通过指定的方法访问数据,可以方便加入控制逻辑,限制不合理的操作
• 便于修改,增强代码的可维护性
• 可进行数据检查

Student类:

例子:
package csdn;

public class Student {
	private int studentId;
	private String name;
	private int age;
	private String classname;
	public Student(){
		this.studentId = 0;
		this.name = "默认";
		this.age = 0;
		this.classname = "Java课堂";
	}
	public Student(int studentId,String name,int age,String classname){
		this.studentId = studentId;
		this.name = name;
		this.age = age;
		this.classname = classname;
	}
	public void display(){
		System.out.println("studentId:"+this.studentId+";name:"+name+";age="+age+";classname:"+this.classname);
	}
	public int getStudentId() {
		return studentId;
	}
	public void setStudentId(int studentId) {
		this.studentId = studentId;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getClassname() {
		return classname;
	}
	public void setClassname(String classname) {
		this.classname = classname;
	}
}

studentTest测试类:

package csdn;

public class StudentTest {
	public static void main(String[] args) {
		Student s1 = new Student();
		s1.display();
		s1.setAge(16);
		s1.setName("张三");
		s1.display();
		System.out.println(s1.getStudentId());
		System.out.println(s1.getClassname());
	}
}

运行结果如下:

studentId:0;name:默认;age=0;classname:Java课堂
studentId:0;name:张三;age=16;classname:Java课堂
0
Java课堂

这样我们就实现了类的封装,只提供修改/获得成员变量的方法,不允许直接对成员变量进行修改;
类的封装在后面会经常使用, 需要掌握这个方法

内部类

将一个类的定义置入另一个类的定义中就叫做"内部类"

普通内部类

• 1.内部类可以访问外部类的成员变量和成员方法(函数)
• 2.外部类不可以访问内部类的成员变量和成员方法(函数)
• 3.普通内部类中不能定义静态(类)变量和静态(类)方法
• 4.在外部类中可以定义内部类的对象
• 5.在函数内部也可以定义内部类
• 6.内部类的字节码文件名称:外部类$内部类.class
• 7.函数内部的内部类字节码文件名称:外部类$1内部类.class
• 8.函数或者语句块内部定义的内部类只能访问函数内部的常量和外部类的成员

package csdn;

public class Outer {
	int count = 10;
	Inner inner = new Inner();//在外部类中可以定义内部类的对象
	public Outer() {}
//	innerName = "我是外部类";错误:外部类不能访问内部类的成员变量和成员方法
//	printInner();
	public void display(){
		System.out.println("我是外部类");
	}
	public void test(){
		//函数内部也可以定义内部类
		//函数或者语句块内定义的内部类只能访问函数内部的常量和外部类成员
		int a = 10;
		class Inner2{
			public void test2(){
				System.out.println(count);//count为外部类的成员变量所以可以访问
//				System.out.println(a);//报错:a在函数或语句块内,所以只有在a为常量是才能在这里访问,将a的定义改为final int a = 10;即可
			}
		}
	}
	class Inner{
		String innerName = "我是内部类";
		public Inner(){
			count = 15;//内部类可以访问外部类的成员变量和成员方法(函数)
		}
		public void printInner(){
			System.out.println("我是内部类");
		}
//		public static void test(){
//			错误:普通内部类中不能定义静态(类)变量和静态(类)方法
//		}
	}
}

这里补充一下静态内部类的使用方法(不同于普通类的使用,静态类的实例化需要借助外部类的对象进行实例化)
这个地方我说的可能不准确,主要看下面的演示代码:

package csdn;

public class OuterTest {
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.display();
		//这里需要强调一下,普通内部类在实例化时需要外部类对象来实例化就像下面的演示
		Outer.Inner inner = outer.new Inner();
		inner.printInner();
	}
}

静态内部类

• 静态内部类只能访问外部类的静态成员,不能访问实例成员
• 静态内部类可以定义静态变量和静态方法

package csdn;

public class Outer2 {
	static String outerName = "我是外部类";
	static class Inner{
		String innerName = "我是静态内部类";
		static int count = 0;//静态内部类可以定义静态(类)变量和静态(类)方法(函数)
		public void display(){
			System.out.println(outerName);//静态内部类只能访问外部类的静态成员,outerName去掉static关键字的话这句会报错
		}
	}
}

• 静态内部类可以直接使用,不需要通过外部类的对象来new内部类
• 静态内部类的使用和普通类一样

package csdn;

public class OuterTest {
	public static void main(String[] args) {
		//静态内部类可以直接使用,不需要外部类的对象来new内部类
		//可以直接使用
		Outer2.Inner2 inner2 = new Outer2.Inner2();
	}
}

今天这篇笔记涉及到的演示较多,写的时间有点长了,有问题的小伙伴可以评论区交流一下,一起学习