访问控制
针对访问权限，Java提供了四种访问控制权限关键字：
- private私有访问权限：也是常见的一种，类成员一旦使用了本权限，则该成员只能在本类中访问
- default默认访问权限：可以被本包中的其他类访问，但是不能被其他包的类访问
- protected受保护的访问权限：只能被本包及不同包的子类访问
- public公共访问权限：最高权限，可以被所有类访问，不论是否在同一包中
- 访问控制级别从小到大依次是：
private(本类)---->default(本包)--->protected(子类)--->public(所有包的类)
- 访问控制权限用法：
class good{
public String name;
//公共权限 被所有类访问
private int age;
//私有权限 仅能在本类访问
private class text{}
//内部私有类 仅在本类使用
}
权限修饰符：public,protected,缺省,private
| 修饰符 | 本类 | 本包 | 其他包子类 | 其他包非子类 |
|---|---|---|---|---|
| private | √ | × | × | × |
| 缺省 | √ | √ | × | × |
| protected | √ | √ | √ | × |
| public | √ | √ | √ | √ |
外部类：public和缺省
成员变量、成员方法、构造器、成员内部类：public,protected,缺省,private
提示：protected修饰非静态成员，**跨包时，**只能在子类的非静态成员中访问，在静态成员中无论是否创建对象都不能访问。
本包非子类与子类
package com.gec.test01.access1;
public class Father {
public int a;
protected int b;
int c;
private int d;
public static int e;
protected static int f;
static int g;
private static int h;
}
class Mother{
public Mother(){
}
}
package com.gec.test01.access1;
//本包非子类中
public class Other {
public static void method(){
Father obj = new Father();
System.out.println(obj.a);
System.out.println(obj.b);
System.out.println(obj.c);
// System.out.println(obj.d);//跨类不可见
System.out.println(Father.e);
System.out.println(Father.f);
System.out.println(Father.g);
// System.out.println(h);//跨类不可见
}
public void fun(){
Father obj = new Father();
System.out.println(obj.a);
System.out.println(obj.b);
System.out.println(obj.c);
// System.out.println(obj.d);//跨类不可见
System.out.println(Father.e);
System.out.println(Father.f);
System.out.println(Father.g);
// System.out.println(h);//跨类不可见
}
}
- 定义一个子类
package com.gec.test01.access1;
//本包子类中
public class Sub extends Father{
public static void method(){
//静态直接访问非静态都不行
/* System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);*/
Father obj = new Father();
System.out.println(obj.a);
System.out.println(obj.b);
System.out.println(obj.c);
// System.out.println(obj.d);//跨类不可见
System.out.println(e);
System.out.println(f);
System.out.println(g);
// System.out.println(h);//跨类不可见
}
public void fun(){
System.out.println(a);
System.out.println(b);
System.out.println(c);
// System.out.println(d);//跨类不可见
System.out.println(e);
System.out.println(f);
System.out.println(g);
// System.out.println(h);//跨类不可见
}
}
封装特性
- 封装性简单来讲就是：防止本类代码和数据被外部程序随机访问，也就是数据隐藏。
- 为什么要封装
public class ct {
String name;
int age;
void print(){
System.out.println("我是"+name+"我今年"+age+"岁啦！");
}
}
public class tt {
public static void main(String[] args) {
ct ct1 = new ct();
ct1.name = "张三";
ct1.age = -1;
ct1.print();
}
}
//输出为：我是张三我今年-1岁啦！
- -1岁是可以存在的，但是客观来讲是一个不合理的年龄，于是就需要在设计类的时候对其进行限定，不允许外部随便访问
public class ct {
String name;
int age;
void print(){
if (age<0 || age>120){
System.out.println("输入的年龄有误！");
}else{
this.age = age;
System.out.println("我是"+name+"我今年"+age+"岁啦！");
}
}
}
//此时输出为：输入的年龄有误！ 说明-1不满足条件
- 将类中的属性封装指，将属性私有化，使用private关键字修饰属性。则该属性只能在本类中访问，若外界想要访问概述性则要通过get/set方法进行访问：
public class ct {
private String name;
private int age;
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;
if (age<0 || age>120){
System.out.println("输入的年龄有误！");
}else{
this.age = age;
}
}
}
public class tt {
public static void main(String[] args) {
ct ct1 = new ct();
//setName用于赋值
//getName用于打印
ct1.setName("张三");
System.out.println(ct1.getName());
ct1.setAge(18);
System.out.println(ct1.getAge());
}
}
/*
输出：
张三
18
*/
//setName用于赋值
//getName用于打印
为属性赋值：
ct1.name = "张三";
为方法传参
ct1.setName("张三");
属性赋值打印：
void print(){
System.out.println("我是"+name+"我今年"+age+"岁啦");
}
利用方法打印：
System.out.println(ct1.getName());
成员变量/属性私有化问题
**成员变量（field）私有化之后，提供标准的get/set方法，我们把这种成员变量也称为属性（property）。**或者可以说只要能通过get/set操作的就是事物的属性，哪怕它没有对应的成员变量。
成员变量封装的目的
- 隐藏类的实现细节
- 让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里面加入控制逻辑，限制对成员变量的不合理访问。还可以进行数据检查，从而有利于保证对象信息的完整性。
- 便于修改，提高代码的可维护性。主要说的是隐藏的部分，在内部修改了，如果其对外可以的访问方式不变的话，外部根本感觉不到它的修改。例如：Java8->Java9，String从char[]转为byte[]内部实现，而对外的方法不变，我们使用者根本感觉不到它内部的修改。
实现步骤
- 使用
private修饰成员变量
private 数据类型 变量名 ；
代码如下：
public class Chinese {
private static String country;
private String name;
private int age;
private boolean marry;
}
- 提供
getXxx方法 /setXxx方法，可以访问成员变量，代码如下：
public class Chinese {
private static String country;
private String name;
private int age;
private boolean marry;
public static void setCountry(String c){
country = c;
}
public static String getCountry(){
return country;
}
public void setName(String n) {
name = n;
}
public String getName() {
return name;
}
public void setAge(int a) {
age = a;
}
public int getAge() {
return age;
}
public void setMarry(boolean m){
marry = m;
}
public boolean isMarry(){
return marry;
}
}
解决局部变量与成员变量同名问题
当局部变量与类变量（静态成员变量）同名时，在类变量前面加“类名."；
当局部变量与实例变量（非静态成员变量）同名时，在实例变量前面加“this.”
构造器（Constructor)
我们发现我们new完对象时，所有成员变量都是默认值，如果我们需要赋别的值，需要挨个为它们再赋值，太麻烦了。我们能不能在new对象时，直接为当前对象的某个或所有成员变量直接赋值呢。
可以，Java给我们提供了构造器。
构造器的作用
在创建对象的时候为实例变量赋初始值。
注意：构造器只为实例变量初始化，不为静态类变量初始化
构造器的语法格式
- 创建对象，触发此构造器
构造器又称为构造方法，那是因为它长的很像方法。但是和方法还有有所区别的。
【修饰符】 构造器名(){
// 实例初始化代码
}
【修饰符】 构造器名(参数列表){
// 实例初始化代码
}
代码如下：
public class Student {
private String name;
private int age;
// 无参构造
public Student() {}
// 有参构造
public Student(String name,int age) {
this.name = name;
this.age = age;
}
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;
}
}
注意事项：
-
构造器名必须与它所在的类名必须相同。
-
它有缺省返回值，所以不需要返回值类型，甚至不需要void
-
如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
-
如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义。
-
构造器是可以重载的，既可以定义参数，也可以不定义参数。一个类可以定义多个构造器，但参数列表不一致
-
构造器的修饰符只能是权限修饰符，不能被其他任何修饰
如果你不提供构造器，系统会给出无参数构造器，并且该构造器的修饰符默认与类的修饰符相同
如果你提供了构造器，系统将不再提供无参数构造器，除非你自己定义
构造器间调用
class oop02{
public static void main(String[]args){
Student stu1 = new Student("张三",21,"中国");
stu1.prin();
}
}
class Student{
private static String country;
private String name;
private int age;
public Student(){}
public Student(String country){this.country = country;}
public Student(String name,int age,String country){this(country);this.name = name;this.age = age;}
void prin(){System.out.print("国籍："+country+",姓名："+name+",年龄："+age);}
}
标准JavaBean
JavaBean 是 Java语言编写类的一种标准规范。符合JavaBean 的类，要求：
（1）类必须是具体的和公共的，
（2）并且具有无参数的构造方法，
（3）成员变量私有化，并提供用来操作成员变量的set 和get 方法。
public class ClassName{
//成员变量
//构造方法
//无参构造方法【必须】
//有参构造方法【建议】
//getXxx()
//setXxx()
//其他成员方法
}
编写符合JavaBean 规范的类，以学生类为例，标准代码如下：
public class Student {
// 成员变量
private String name;
private int age;
// 构造方法
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
// get/set成员方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return age;
}
//其他成员方法列表
public String getInfo(){
return "姓名：" + name + "，年龄：" + age;
}
}
测试类，代码如下：
public class TestStudent {
public static void main(String[] args) {
// 无参构造使用
Student s = new Student();
s.setName("柳岩");
s.setAge(18);
System.out.println(s.getName() + "---" + s.getAge());
System.out.println(s.getInfo());
// 带参构造使用
Student s2 = new Student("赵丽颖", 18);
System.out.println(s2.getName() + "---" + s2.getAge());
System.out.println(s2.getInfo());
}
}
扫一扫
1193
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
