Java三大特征、访问修饰符
Java访问修饰符
| 权限修饰符 | 同一个类 | 同一个包 | 子类 | 不同包|任意类 |
|---|---|---|---|---|
| private | 可以 | |||
| 默认 | 可以 | 可以 | ||
| protected | 可以 | 可以 | 可以 | |
| public | 可以 | 可以 | 可以 | 可以 |
注:类的修饰符只能是public或者默认
1、Java包(package)
为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包的作用：
-
把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
-
如同文件夹一样，包也采用了树形目录存储方式。包可以避免名字冲突。
-
包限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。
包语句的语法格式为：
package pkg1[．pkg2[．pkg3…]];
2、Java成员变量权限修饰符
案例:
代码如下：
package com.star.demo05.pojo;
public class Student {
private int id;
String name;
protected String age;
public String address;
public Student() {}
public Student(int id, String name, String age, String address) {
//本类中全部都可以访问
this.id = id;
this.name = name;
this.age = age;
this.address = address;
}
}
----------------------------------------------------------------------------
package com.star.demo05.pojo;
public class Test {
public static void main(String[] args) {
Student student = new Student();
//System.out.println(student.id);//不能访问
System.out.println(student.name);//默认值：null
System.out.println(student.age);//默认值：null
System.out.println(student.address);//默认值：null
}
}
----------------------------------------------------------------------------
package com.star.demo05.main;
import com.star.demo01.pojo.Student;
public class main {
public static void main(String[] args) {
// 创建方法1，使用无参数构造函数
Student student1 = new Student();
// 创建方法2，使用有参数构造函数
Student student2 = new Student(2,"张三","男","地球");
//System.out.println(student1.id);//不能访问
//System.out.println(student1.name);//不能访问
//System.out.println(student1.age);//不能访问
//System.out.println(student2.id);//不能访问
//System.out.println(student2.name);//不能访问
//System.out.println(student2.age);//不能访问
System.out.println(student1.address);//null
System.out.println(student2.address);//地球
}
}
**注:**带有包的编译需要在包的顶层目录中执行命令
**注:**带有包的运行需要在类名前加上包路径
3、Java成员函数修饰符
代码如下：
package com.star.demo06.pojo;
public class Student {
private void privateFun() {
System.out.println("私有权限方法");
}
void defaultFun() {
System.out.println("默认权限方法");
}
protected void protectedFun() {
System.out.println("保护权限方法");
}
public void publicFun() {
System.out.println("公开权限方法");
}
}
----------------------------------------------------------------------------
package com.star.demo06.pojo;
public class Test {
public static void main(String[] args) {
// 创建方法1，使用无参数构造函数
Student student1 = new Student();
//student1.privateFun();//不能调用
student1.defaultFun();//不能调用
student1.protectedFun();//不能调用
student1.publicFun();
}
}
----------------------------------------------------------------------------
package com.star.demo01.main;
import com.star.demo01.pojo.Student;
public class Main {
public static void main(String[] args) {
// 创建方法1，使用无参数构造函数
Student student1 = new Student();
//student1.privateFun();//不能调用
//student1.defaultFun();//不能调用
//student1.protectedFun();//不能调用
student1.publicFun();
}
}
4、案例
考试系统
对象：试卷、试题，试题类型，答案、考试、分数
试卷：标题，考试时间、开始时间、交卷时间、试题集合(数组)、考生
试题：试题类型，题目，答案选项集合(数组)，标准答案(数组)
试题类型：类型名称，分值/每题，
答案：答案标号，答案内容
考生：姓名，性别
Java三大特性
JAVA的三大特性：封装、继承、多态
1、封装
**核心：**隐藏对象的内部属性（成员变量）和行为（成员函数）
体现：（低耦合高内聚）
- 相关的代码提炼到一个函数中，不相关的代码分离成不同函数
- 不相关的属性和行为不放在一个类中，相关的属性和方法放到一个类中
- 不相关的模块放到一个包中，不相关的模块放到不同包中
好处：
- 保护函数和对象内部的属性和方法
- 禁止对象之间的不良交互，提高模块化
- 对象的行为可以被单独的改变或者是扩展，而不影响别的模块
- 提高了代码的重用性和可维护性
功能相关的代码放到一起（一个函数、一个类、一个包），也能实现代码的重用
package com.star.demo08;//相关功能放在一个包里面
// 一个类体现一种类型的事物的封装
public class User {
//封装相关的一些列的属性
private String name = "UserName";
String sex = "男";
protected int age = 20;
public String address = "地球";
//封装实现该对象的功能的相关的一些函数
//无参数的构造函数
public User() {
super();
}
//封装实现该对象的功能的相关的一些函数
//带参数的构造函数
public User(String name, String sex, int age, String address) {
super();
this.name = name;
this.sex = sex;
this.age = age;
this.address = address;
}
//getter...
//setter...
}
2、继承
核心：从基类(父类)获取非私有属性和方法的能力
体现：（代码重用）
- Java中一个类只能继承一个父类（单继承）
- 只能获取访问权限非private的属性和方法
- 子类可以重写父类中的同名属性和方法
好处：提高代码重用性
继承使用关键词【extends】
继承别的类的来称之为子类，被继承的类称之为父类
子类中使用【super】来调用父类的属性和方法
语法：
class Child extends Base
package com.star.demo09;
//被继承的基类
public class Base {
private String arg1;
String arg2;
protected String arg3;
public String arg4;
public String teg;
//构造函数中给所有属性初始值
public Base() {
System.out.println("Base 的无参数构造函数");
this.arg1 = "Base私有的参数";
this.arg2 = "Base默认的参数";
this.arg3 = "Base受保护的参数";
this.arg4 = "Base公开的参数";
this.teg = "Base";
}
public void show() {
System.out.println("我是Base类的show方法");
}
}
----------------------------------------------------------------------------
package com.star.demo09;
public class Child extends Base {
public String my;
public Child() {
System.out.println("Child的无参数构造函数");
this.my = "Child自己的属性";
//修改父类的teg属性的值
super.teg = teg+this.teg;
}
}
----------------------------------------------------------------------------
package com.star.demo09;
public class Main {
public static void main(String[] args) {
Base base = new Base();
System.out.println("------------------");
Child child = new Child();
System.out.println("------------------");
// System.out.println(base.arg1);
System.out.println(base.arg2);
System.out.println(base.arg3);
System.out.println(base.arg4);
System.out.println(base.teg);
System.out.println("------------------");
// System.out.println(child.arg1);
System.out.println(child.arg2);
System.out.println(child.arg3);
System.out.println(child.arg4);
System.out.println(child.teg);
System.out.println("------------------");
base.show();
System.out.println("------------------");
child.show();
}
}
3、多态
**核心：**相同调用表现出不同结果
体现：
-
重载：根据函数参数的个数、**类型、顺序（类型不同）**不同实现同名但功能不同的函数
-
重写：子类覆写父类相同函数，且父类和子类分别具有独立的一套函数
-
引用：父类引用指向子类的对象，但是只能调用父类有的属性和函数
**注：**父类引用指向子类的对象时，优先调用子类的方法。如果子类没有重写父类的方法，则再调用父类的方法。
好处：增加代码的灵活度
**注：**应尽量减少继承关系，以降低耦合度
package com.star.demo10;
//被继承的基类
public class Base {
public String teg;
// 构造函数中给所有属性初始值
public Base() {
this.teg = "Base";
}
// 重载的构造函数
public Base(String teg) {
this.teg = teg;
}
public void show() {
System.out.println("我是Base类的show方法");
}
// 重载的show函数
public void show(String teg) {
System.out.print("我是Base类的show方法，");
System.out.println("参数:teg=" + teg);
}
// 重载的show函数：参数的类型不同
public void show(int teg) {
System.out.print("我是Base类的show方法，");
System.out.println("参数:teg=" + teg);
}
// 重载的show函数：参数的个数不同
public void show(int teg, String abc) {
System.out.print("我是Base类的show方法，");
System.out.println("参数:teg=" + teg + ";abc=" + abc);
}
// 重载的show函数:参数的顺序不同
public void show(String abc, int teg) {
System.out.print("我是Base类的show方法，");
System.out.println("参数:teg=" + teg + ";abc=" + abc);
}
}
----------------------------------------------------------------------------
package com.star.demo10;
public class Child extends Base {
public String my;
public Child() {
this.my = "Child自己的属性";
this.teg = "Child";
// 修改父类的teg属性的值
super.teg = teg + this.teg;
}
public void show() {
System.out.println("我是Child类的show方法");
}
// 重载的show函数
@Override
public void show(String teg) {
System.out.print("我是Child类的show方法，");
System.out.println("参数:teg=" + teg);
}
// 重载的show函数：参数的类型不同
@Override
public void show(int teg) {
System.out.print("我是Child类的show方法，");
System.out.println("参数:teg=" + teg);
}
}
----------------------------------------------------------------------------
package com.star.demo10;
public class Main {
public static void main(String[] args) {
Base base = new Base();
Child child = new Child();
Base base_child = new Child();
System.out.println("------------------");
System.out.println(base.teg);
System.out.println("------------------");
System.out.println(child.teg);
System.out.println("------------------");
base.show();
base.show("base-String");
base.show(-1000);
base.show(-1000, "base-base-base");
base.show("base1-base1-base1", -1000);
System.out.println("------------------");
child.show();
child.show("child-String");
child.show(1000);
child.show(1000, "child-child-child");
child.show("child1-child1-child1", 1000);
System.out.println("------------------");
System.out.println("------------------");
base_child.show();
base_child.show("base_child");
base_child.show(9999);
base_child.show(9999, "base_child");
base_child.show("base_child", 999);
System.out.println("------------------");
}
}
2915
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
