作者 :ふり
专栏 :JavaSE
格言 : I came ; I saw ; I conquer
一、封装
1.1 封装的概念
- 面向对象程序三大特性:封装、继承、多态。而类和对象阶段,主要研究的就是封装特性。何为封装呢?简单来说就是套壳屏蔽细节。
- 比如:对于电脑这样一个复杂的设备,提供给用户的就只是:开关机、通过键盘输入,显示器,USB插孔等,让用户来和计算机进行交互,完成日常事务。但实际上:电脑真正工作的却是CPU、显卡、内存等一些硬件元件
- 对于计算机使用者而言,不用关心内部核心部件,比如主板上线路是如何布局的,CPU内部是如何设计的等,用户只需要知道,怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时,在外部套上壳子,将内部实现细节隐藏起来,仅仅对外提供开关机、鼠标以及键盘插孔等,让用户可以与计算机进行交互即可。
封装:将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互
。
1.2 访问限定符
- Java中主要通过类和访问权限来实现封装:
类可以将数据以及封装数据的方法结合在一起,更符合人类对事物的认知,而访问权限用来控制方法或者字段能否直接在类外使用
。Java中提供了四种访问限定符:
No | 范围 | private ( 私有的) | default ( 默认的 ) | protected ( 受保护的) | public ( 公开的) |
---|---|---|---|---|---|
1 | 同一包中的同一类 | ✔ | ✔ | ✔ | ✔ |
2 | 同一包中的不同类 | ✔ | ✔ | ✔ | |
3 | 不同包中的子类 | ✔ | ✔ | ||
4 | 不同包中的非子类 | ✔ |
比如:
- public:可以理解为一个人的外貌特征,谁都可以看得到
- default: 对于自己家族中(同一个包中)不是什么秘密,对于其他人来说就是隐私了-
- private:只有自己知道,其他人都不知道
【说明】
- protected主要是用在继承中,继承部分详细介绍
- default权限指:什么都不写时的默认权限
- 访问权限除了可以限定类中成员的可见性,也可以控制类的可见性
- 注意:一般情况下成员变量设置为private,成员方法设置为public。
1.3 封装扩展之包
1.3.1 包的概念
- 在面向对象体系中,提出了一个软件包的概念,即:
为了更好的管理类,把多个类收集在一起成为一组,称为软件包
。有点类似于目录。比如:为了更好的管理电脑中的歌曲,一种好的方式就是将相同属性的歌曲放在相同文件下,也可以对某个文件夹下的音乐进行更详细的分类。
- 在Java中也引入了包,
包是对类、接口等的封装机制的体现,是一种对类或者接口等的很好的组织方式
,比如:一个包中的类不想被其他包中的类使用。包还有一个重要的作用:在同一个工程中允许存在相同名称的类,只要处在不同的包中即可
。
1.3.2 导入包中的类
- Java 中已经提供了很多现成的类供我们使用. 例如Date类:可以使用 java.util.Date 导入 java.util 这个包中的 Date类.
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
- 但是这种写法比较麻烦一些, 可以使用 import语句导入包
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
- 如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
import java.util.*;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
- 但是我们
更建议显式的指定要导入的类名. 否则还是容易出现冲突
的情况
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 都匹配
- 在这种情况下需要使用完整的类名
import 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
1.3.3 自定义包
基本规则:
在文件的最上方加上一个 package 语句指定该代码在哪个包中. 包名需要尽量指定成唯一的名字,
通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中.
操作步骤:
- 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包
-
在弹出的对话框中输入包名, 例如 Demo1
-
在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.
-
此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了
- 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句
1.3.4 常见的包
- java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
- java.lang.reflect:java 反射编程包;
- java.net:进行网络编程开发包。
- java.sql:进行数据库开发的支持包。
- java.util:是java提供的工具程序包。(集合类等) 非常重要
- java.io:I/O编程开发包。
二、 static成员
2.1 static修饰成员变量
static修饰的成员变量
,称为静态成员变量
,静态成员变量最大的特性:不属于某个具体的对象
,是所有对象所共享的
。
【静态成员变量特性】
- 不属于某个具体的对象,是类的属性,
所有对象共享的
,不存储在某个对象的空间中- 既可以通过对象访问,也可以通过类名访问,但
一般更推荐使用类名访问
- 类变量存储在
方法区
当中- 生命周期伴随类的一生(即:随类的加载而创建,随类的卸载而销毁)
public class Student {
public String name;
public int age;
//因为几个人会一样,所以用静态成员变量
public static String classes = "六班";
public Student(String name,int age){
this.name = name;
this.age = age;
}
public void print(){
// 静态成员变量可以直接通过类名访问
System.out.println(this.name+" - "+this.age+" - "+Student.classes);
}
public static void main(String[] args) {
Student student = new Student("张三",16);
student.print();
// 也可以通过对象访问 (不推荐)
/*System.out.println(student.name);
System.out.println(student.age);
System.out.println(student.classes);*/
}
}
2.2 static修饰成员方法
- 一般类中的数据成员都设置为private,而成员方法设置为public,那设置之后,Student类中classes属性如何在类外访问呢?
- static属性应该如何访问呢
- Java中,
被static修饰的成员方法称为静态成员方法,是类的方法,不是某个对象所特有的
。静态成员一般是通过静态方法来访问的。
public class Student{
// ...
private static String classes = "六班";
// ...
public static String classes(){
return classes;
}
}
public class TestStudent {
public static void main(String[] args) {
System.out.println(Student.classes());
}
}
【静态方法特性】
- 不属于某个具体的对象,是类方法
- 可以通过对象调用,也可以通过类名.静态方法名(…)方式调用,更推荐使用后者
- 不能在静态方法中访问任何非静态成员变量
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
- 静态方法中不能调用任何非静态方法,因为非静态方法有this参数,在静态方法中调用时候无法传递this引用
- 静态方法无法重写,不能用来实现多态
2.4 static成员变量初始化
静态成员变量的初始化分为两种:就地初始化 和 静态代码块初始化。
- 就地初始化
就地初始化指的是:在定义时直接给出初始值
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "六班";
// ...
}
- 静态代码块初始化
那什么是代码块呢?继续往后看 😃 ~~~
三、代码块
3.1 代码块概念以及分类
使用
{ }
定义的一段代码称为代码块。根据代码块定义的位置以及关键字,又可分为以下四种:
- 普通代码块
- 构造块
- 静态块
- 同步代码块(后续讲解多线程部分再谈)
3.2 普通代码块
普通代码块:定义在方法中的代码块
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义,普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
} /
/ 执行结果
x1 = 10
x2 = 100
3.3 构造代码块
构造块:定义在类中的代码块(不加修饰符)。也叫:实例代码块。构造代码块一般用于初始化实例成员变量。
public class Student{
//实例成员变量
private String name;
private String gender;
private int age;
private double score;
public Student() {
System.out.println("I am Student init()!");
}
//实例代码块
{
this.name = "erzi";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}
// 运行结果
I am instance init()!
I am Student init()!
name: erzi age: 12 sex: man
3.4 静态代码块
使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量
。
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "erzi";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
// 静态代码块
static {
classRoom = "erzi306";
System.out.println("I am static init()!");
}
public Student(){
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}
注意事项
- 静态代码块不管生成多少个对象,其只会执行一次
- 静态成员变量是类的属性,因此是在JVM加载类时开辟空间并初始化的
- 如果一个类中包含多个静态代码块,在编译代码时,编译器会按照定义的先后次序依次执行(合并)
- 实例代码块只有在创建对象时才会执行
- 例子 :
public class Student {
public String name;
public int age;
public static String classes = "六班";
{
System.out.println("实例代码块");
}
static {
System.out.println("静态代码块");
}
public Student(){
this.name = name;
this.age = age;
System.out.println("不带参数的构造方法");
}
public void setStudent(String name,int age){
this.name = name;
this.age = age;
}
public void print(){
System.out.println(this.name+" - "+this.age+" - "+Student.classes);
}
public static void main(String[] args) {
Student student = new Student();
student.setStudent("张三",6);
student.print();
}
}
//实现顺序
//静态代码块(同为静态谁先出就是谁先)
//实例代码块
//不带参数的构造方法
//张三 - 6 - 六班
四、内部类
当一个事物的内部,还有一个部分需要一个完整的结构进行描述,而这个内部的完整的结构又只为外部事物提供服务,那么整个内部的完整结构最好使用内部类。
在 Java 中,可以将一个类定义在另一个类或者一个方法的内部, 前者称为内部类,后者称为外部类。内部类也是封装的一种体现
public class OutClass {
class InnerClass{
}
}
// OutClass是外部类
// InnerClass是内部类
内部类 :
1.实例内部类 / 非静态内部类
2.静态内部类
3.局部内部类
4.匿名内部类
- 获取实例内部类对象
class OuterClass{
public int data1;
int data2;
public static int data3;
/**
* 实例内部类
* 1.获取实例内部类对象
*/
class InnerClass{
public int data4;
int data5;
public void func(){
System.out.println("InnerClass::func");
}
}
}
public class Test {
public static void main(String[] args) {
//法一:
OuterClass outerClass = new OuterClass();
System.out.println(outerClass.data1);
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
//类型 变量 .( )
//法二:
//OuterClass.InnerClass innerClass1 = new OuterClass().new InnerClass();
}
}
- 实例内部类中 不能有静态的成员变量
class OuterClass{
public int data1;
int data2;
public static int data3;
/**
* 实例内部类
* 1.获取实例内部类对象
* 2.实例内部类中 不能有静态的成员变量,非要定义,必须是 static final 修饰的
*/
class InnerClass{
public int data4;
int data5;
public static final int DATA6 = 10;
//一般大写
//final 可以变成常量,常量是在程序编译时确定的,一旦确定不可变化
public void func(){
System.out.println("InnerClass::func");
}
}
}
public class Test {
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
System.out.println(outerClass.data1);
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
}
}
- .当内部类和外部类存在变量名相同情况下,会采用就近原则
- 在实例内部类中访问外部类相同的变量
class OuterClass{
public int data1 = 1;
int data2 = 2;
public static int data3 = 3;
/**
* 实例内部类
* 1.获取实例内部类对象
* 2.实例内部类中 不能有静态的成员变量,非要定义,必须是 static final 修饰的
* 3.当内部类和外部类存在变量名相同情况下,会采用就近原则
* 4.在实例内部类中访问外部类相同的变量
*/
class InnerClass{
public int data1 = 8888;
public int data4 = 4;
int data5 = 5;
public static final int DATA6 = 6; //final 可以变成常量
public void func(){
//就近原则
System.out.println(data1);
//在实例内部类中访问外部类相同的变量
System.out.println(OuterClass.this.data1);
System.out.println(data2);
System.out.println(data3);
System.out.println(data4);
System.out.println(data5);
System.out.println(DATA6);
}
}
}
public class Test {
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.func();
}
}
【注意事项】
- 外部类中的任何成员都可以在实例内部类方法中直接访问
- 实例内部类所处的位置与外部类成员位置相同,因此也受public、private等访问限定符的约束
- 在实例内部类方法中访问同名的成员时,优先访问自己的,如果要访问外部类同名的成员,必须:外部类名 称.this.同名成员 来访问
- 实例内部类对象必须在先有外部类对象前提下才能创建
- 实例内部类的非静态方法中包含了一个指向外部类对象的引用
- 外部类中,不能直接访问实例内部类中的成员,如果要访问必须先要创建内部类的对象。
4.1 静态内部类
class OuterClass{
public int data1 = 1;
int data2 = 2;
public static int data3 = 3;
/**
* 静态内部类
* 1.获取静态内部类对象
* OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
* 2.静态内部类中不能访问外部类的非静态成员,外部类的非静态成员需要通过外部类的对象的引用才可以访问
* 3.,如果非要访问,那么如何才可以访问
* OuterClass outerClass = new OuterClass();
* System.out.println(outerClass.data1);
* 4.
*/
static class InnerClass{
public int data4 = 4;
int data5 = 5;
public static int data6 = 6;
public void func(){
OuterClass outerClass = new OuterClass();
System.out.println(outerClass.data1);
System.out.println(data4);
System.out.println(data5);
System.out.println(InnerClass.data6);
}
}
}
public class Test {
public static void main(String[] args) {
OuterClass.InnerClass innerClass = new OuterClass.InnerClass();
innerClass.func();
}
}
4.2 局部内部类
定义在外部类的方法体或者{}中,该种内部类只能在其定义的位置使用,一般使用的非常少,此处简单了解下语法格式。
public class OutClass {
int a = 10;
public void method(){
int b = 10;
// 局部内部类:定义在方法体内部
// 不能被public、static等访问限定符修饰
class InnerClass{
public void methodInnerClass(){
System.out.println(a);
System.out.println(b);
}
}
// 只能在该方法体内部使用,其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();
}
public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 编译失败
}
}
【注意事项】
- 局部内部类只能在所定义的方法体内部使用
- 不能被public、static等修饰符修饰
- 编译器也有自己独立的字节码文件,命名格式:外部类名字$内部类名字.class
- 几乎不会使用
4.3 匿名内部类
class Person{
public int age = 22;
public String name = "张三";
}
public class Test {
public static void main(String[] args) {
System.out.println(new Person().age);//匿名对象
System.out.println(new Person().name);//匿名对象 只能使用一次 每次用都得重新 new
//匿名内部类
new Person(){
};
}
}
五、对象的打印
class Person{
public String name;
public int age;
public Person(String name,int age){
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Test {
public static void main(String[] args) {
Person person = new Person("张三",22);
System.out.println(person);
}
}
- tostring 右键 => generate => tostring