上一章节“对象的构造方法和初始化”传送门:
目录
一、封装
1、封装的概念
面向对象程序三大特性:封装、继承、多态。而类和对象阶段,主要研究的就是封装特性。何为封装呢?简单来说 就是套壳屏蔽细节。
例如我们平时在用的电脑,我们只需关注电脑外部的设备或功能,而电脑内部的显卡、cpu、硬盘等这些都是被隐藏起来的。看似是计算机提供给我们用户开关机、通过键盘输入,显示器,USB插孔等,让用 户来和计算机进行交互,完成日常事务。
但对于计算机使用者而言,不用关心内部核心部件,比如主板上线路是如何布局的,CPU内部是如何设计的等,用户 只需要知道,怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时,在外部套上壳子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以及键盘插孔等,让用户可以与计算机进行交互即可。
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。
我们可以利用一个公开的成员方法,在类内对其隐藏了的成员变量进行操作----只能类中使用。
【总结】:对类的实现细节进行隐藏,对外只提供公开的方法来供你使用,可以保持数据的安全性。
2、访问权限修饰符
Java中主要通过类和访问权限来实现封装:类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认 知,而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符:
范围 private default(默认包访问权限) protected public 1 同一个类中的同一类 √ √ √ √ 2 同一包中的不同类 √ √ √ 3 不同包中的子类 √ √ 4 不同包中的非子类 √
四种访问权限修饰符其中:
- public(公开的):无论在哪个类中,还是哪个包中都可以对其进行访问
- private(私有的):只在同一包中的同一类中,才可以访问
- default(默认的):在使用的时候,不用写default修饰符,什么都不写,会直接默认为包访问权限
- protected(受保护的):可以在不同包中的子类中访问,非子类的都不行。
【注意】:(1)protected主要用在继承体系中;
(2)访问权限除了可以限定类中成员的可见性,也可以控制类的可见性。
代码示例:
class Person{
public String name;
private int age;
String sex;
protected int score;
public Person(String name,int age,String sex,int score){
this.name=name; //姓名
this.age=age; //年龄
this.sex=sex; //性别
this.score=score; //成绩
}
}
public class TestDemo {
public static void main(String[] args) {
Person person=new Person("LiHua",15,"boy",98);
System.out.println(person.name); //public修饰的,可以任何其他类访问
System.out.println(person.age); //private修饰的,只能在本包的类中访问
System.out.println(person.sex); //default修饰的,可以在本包的任何类中访问
System.out.println(person.score); //protected修饰的,可以在不同包的子类中使用(继承)
}
}
【注意】:一般情况下成员变量设置为private,成员方法设置为public。然后通过类中公开的成员方法对其被private修饰的成员进行访问!
3、封装扩展包
3.1、包的概念
在面向对象体系中,提出了一个软件包的概念,即:为了更好的管理类,把多个类收集在一起成为一组,称为软件包。有点类似于目录。比如:为了更好的管理电脑中的歌曲,一种好的方式就是将相同属性的歌曲放在相同文件 下,也可以对某个文件夹下的音乐进行更详细的分类。
通过一个包对一些类进行包装,可以更好的整理类。
在Java中也引入了包,包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式,比如:一 个包中的类不想被其他包中的类使用。包还有一个重要的作用:在同一个工程中允许存在相同名称的类,只要处在不同的包中即可。
3.2、导入包中的类
我们在前几章有使用过导包,通过导入jdk自带的工具包来进行++一系列操作(如:import java.util.Scanner;),此处使用了java.util导入了Scanner这个包。
代码示例:
import java.util.Scanner;
public class TestDemo1 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一个数字:");
int n=scanner.nextInt();
System.out.println("打印结果:"+n);
}
}
//运行结果:
请输入一个数字:
5
打印结果:5
我们也可以不导包,直接使用java.util中Scanner这个类。但是这种写法不太推荐比较麻烦(在某些特殊情况也会适合使用)。
public class TestDemo1 {
public static void main(String[] args) {
java.util.Scanner scanner=new java.util.Scanner(System.in);
System.out.println("请输入一个数字:");
int n=scanner.nextInt();
System.out.println("打印结果:"+n);
}
}
//运行结果:
请输入一个数字:
45
打印结果:45
如果需要使用 java.util 中的其他类, 可以使用 import java.util.*(使用这种格式,可以使用java.util包中所有的类,但不是直接将该包中所有的类都包含,而是在我们使用某种类的时候,编译器会自动地去找到对应适用的类)
import java.util.*;
public class TestDemo1 {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入一个数字:");
int n=scanner.nextInt();
System.out.println("打印结果:"+n);
}
}
//运行结果:
请输入一个数字:
123
打印结果:123
【注意】:对于这种写法不推荐,用这种写法容易出现在导不同包时,出现同名的类,而出现的冲突。
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}
// 编译出错
Error:(5, 9) java: 对Date的引用不明确
java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配
在这种情况下,我们可以使用完整的类名
mport java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
System.out.println(date.getTime());
}
}
在导包的时候,可以使用import static导入包中静态的字段或方法!
import static java.lang.Math.*;
public class Test {
public static void main(String[] args) {
double x = 30;
double y = 40;
// 静态导入的方式写起来更方便一些.
// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
double result = sqrt(pow(x, 2) + pow(y, 2));
System.out.println(result);
}
}
用这种导包方式,可以省略掉在访问其类的时候所需要的类名。(但为了代码严谨性,还是不太推荐用这种方法)
【注意】:import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要. import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using。
3.3、自定义包
基本规则:
- 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
- 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
- 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储 代码.
- 如果一个类没有 package 语句, 则该类被放到一个默认包中
操作步骤:
(1)创建一个包
(2)输入包名
之后在对应的包中新建类即可。
(3)创建后,可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了
(4)且创建类后,在该TestDemo文件的开头会自动多出一个声明(package)语句
3.4、包访问权限的注意事项
我们在另外一个包中,如果想使用其他包中的类,可以通过导包的方式进行访问,imoort+包的路径名。
此处导包后,可以通过www包中的TestDemo类实例化一个对象后,对其对象进行访问.
但这么做的前提是被调用包内类必须是公开的,如果是默认权限或private之类的权限修饰,则是无法访问的。
3.5、常见的包
1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
2. java.lang.reflect:java 反射编程包;
3. java.net:进行网络编程开发包。
4. java.sql:进行数据库开发的支持包。
5. java.util:是java提供的工具程序包。(集合类等) 非常重要
6. java.io:I/O编程开发包。
二、static关键字
1、static成员
当我们在定义一个学生类的时候,一个学生必然是各有各的属性,但也不乏会存在相同的属性,比如:性别、班级、年龄之类。那我们在进行描述的时候,应该怎么实现呢?
以下我们假设定义三个学生,来自同一班级,直接让其班级的成员变量就地初始化。
class Student { public String name; public int age; public int classes=101; public String sex; public Student(String name,int age,String sex){ this.name=name; this.age=age; this.sex=sex; } } public class TestDemo { public static void main(String[] args) { Student student1=new Student("小明",16,"boy"); Student student2=new Student("小红",15,"girl"); Student student3=new Student("李华",16,"boy"); } }
那我们是否可以直接添加一个新的成员变量,来保存同学上课时的教室呢?答案是不行的。
之前在Student类中定义的成员变量,每个对象中都会包含一份(称之为实例变量),因为需要使用这些信息来描述 具体的学生。而现在要表示学生上课的教室,这个教室的属性并不需要每个学生对象中都存储一份,而是需要让所 有的学生来共享。在Java中,被static修饰的成员,称之为静态成员,也可以称为类成员,其不属于某个具体的对象,是所有对象所共享的。
static是类的,不是依赖于对象的。
静态不在某个对象的空间中,而是存储在JVM中方法区内。
在类中字段和方法可以划分为:
2、static修饰成员变量
static修饰的成员变量,称为静态成员变量,静态成员变量最大的特性:不属于某个具体的对象,是所有对象所共享的。
【静态成员变量特性】
1. 不属于某个具体的对象,是类的属性,所有对象共享的,不存储在某个对象的空间中。
2. 既可以通过对象访问,也可以通过类名访问,但一般更推荐使用类名访问。
3. (方法区在jvm实现的时候是在堆里面的,但实际上方法区和堆是同一等级的),只不过在JVM当中实现这个 静态修饰的成员时,把他放在了堆里面。方法区在逻辑上是堆的一部分。
4. 类变量存储在方法区当中。
5. 生命周期伴随类的一生(即:随类的加载而创建,随类的卸载而销毁)。
代码示例:
class Student {
public String name;
public int age;
public static int classes=101;
public String sex;
public Student(String name,int age,String sex){
this.name=name;
this.age=age;
this.sex=sex;
}
}
public class TestDemo {
public static void main(String[] args) {
Student student1 = new Student("小明", 16, "boy");
Student student2 = new Student("小红", 16, "girl");
System.out.println(student1.classes);
System.out.println(student2.classes)
//静态变量可以通过对象访问,但classes会被多个对象所共享
System.out.println(Student.classes);//静态变量也可以直接通过类名来访问
}
}
//运行结果:
101
101
对该代码进行调试可以得知,在监视窗口中可以看到,静态成员变量并没有存储到某个具体的对象中。
3、static修饰成员方法
Java中,被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的。静态成员一般是通过静态方法来访问的。没被static修饰的成员方法称为普通成员方法,可以直接通过对象访问。
class Student { public String name; public int age; public static int classes=101; public String sex; public Student(String name,int age,String sex){ this.name=name; this.age=age; this.sex=sex; } } public class TestDemo { public static void main(String[] args) { System.out.println(Student.classes); } } //运行结果: 101
main方法是被static修饰的静态成员方法,可以访问静态成员变量。
【静态方法特性】
1. 不属于某个具体的对象(不依赖于对象),是类方法
2. 可以通过对象调用,也可以通过类名.静态方法名(...)方式调用,更推荐使用后者
3.在静态方法中,不能使用this关键字引用类的实例(this是当前对象的引用,绝对不能在静态方法中使用!),因为静态方法是与类本身相关联的,而不是与类的实例相关联的。静态方法是在类加载时创建的,而不是在创建类的实例时创建的。因此,静态方法不能访问非静态成员,因为非静态成员是在类的实例化时创建的
public static String getClassRoom(){ System.out.println(this); return classRoom; } // 编译失败:Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this public static String getClassRoom(){ age += 1; return classRoom; } // 编译失败:Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age
4. 静态方法中不能调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用时候无法传递this引用。
public static String getClassRoom(){ doClass(); return classRoom; } // 编译报错:Error:(35, 9)java:无法从静态上下文中引用非静态的方法doClass()
5、在普通成员方法可以调用静态成员方法,因为普通成员方法(非静态成员方法,而非静态成员方法是依赖于对象的)要调用,一定会先实例化一个对象才可以调用,而实例化一个对象后,也就可以访问.
【静态方法里面不能调用非静态方法,但是非静态方法可以调用静态方法。这是因为静态方法是在类加载时创建的,而非静态方法是在类的实例化时创建的。因此,非静态方法可以访问静态成员和非静态成员,而静态方法只能访问静态成员】
如果想要在静态方法中调用非静态方法,需要在静态方法中先创建类的实例,然后使用该实例来调用非静态方法。
三、总结
本章节中介绍了类和对象中的”封装“和”static“。
(1)对于封装,我们需要掌握访问修饰符的用处和使用,对应哪种访问权限在什么时候
(2)封装扩展包中的导包(import),自定义包后需要声明,一般包名的命名格式为:用公司的域名的颠倒形式(例如 com.bit.demo1 )使用时还得注意包的访问权限。
(3)static修饰的成员变量和成员方法为静态成员变量(类变量)和静态成员方法(类方法)
(4)非静态成员方法内可以调用静态成员方法,而静态成员方法内不可以调用静态成员方法。(静态成员方法内不能使用this(this是当前对象的引用,是依赖于对象的))。
(5)static静态成员是类的,往往对应的变量和方法被称为类变量和类方法,它不是依赖于对象的!