【0基础学Java第七课】– 类和对象02

7.类和对象02

7.6 封装
- 7.6.1 封装的概念
- 7.6.2 访问限定符
- 7.6.3封装扩展之包
- - a.包的概念
  - b. 导入包中的类
  - c. 自定义包
  - d 常见的包
7.7 static 成员
- 7.7.2 静态修饰成员变量
- 7.7.4 static修饰成员方法
- 7.7.5 static成员变量初始化
7.8 代码块
- 7.8.1 代码块概念以及分类
- 7.8.2 普通代码块
- 7.8.3 构造代码块
- 7.8.4 静态代码块
7.9 内部类
- 7.9.1 内部类的分类
- 7.9.2 内部类
- - 实例内部类
  - 静态内部类
  - 匿名内部类（以后用的比较多）
- 7.9.3 局部内部类
7.10 对象的打印

7.6 封装

7.6.1 封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性，何为封装呢？简单来说就是套壳屏蔽细节。
比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。
对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。
封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

class Student {//构造方法也是可以被封装的只能在当前类当中使用private String name;//private当前成员变量只能在当前类中使用public int age;public Student(String name, int age) {this.name = name;this.age = age;}public void setName(String name) {this.name = name;}public void eat() {System.out.println(this.name+" 正在吃饭！");//Student student = new Student("张三",10);}public String getName() {return this.name;}}public class Test {public static void main(String[] args) {Student student = new Student("张三",10);//student.name = "xiao";实现封装后 类外就无法 拿到这个name字段了student.setName("小王");System.out.println(student.getName());student.eat();}}

注意：

实现封装后类外就无法拿到封装里的字段
构造方法也是可以被封装的只能在当前类当中使用

7.6.2 访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：

说明：

protected主要是用在继承中，继承部分详细介绍
default权限指：什么都不写时的默认权限
访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

一般情况下成员变量设置为private，成员方法设置为public。

7.6.3封装扩展之包

a.包的概念

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包。有点类似于目录。比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件下，也可以对某个文件夹下的音乐进行更详细的分类。

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

b. 导入包中的类

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.*

mport 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);}}

c. 自定义包

基本规则

在文件的最上方加上一个 package 语句指定该代码在哪个包中.
包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中.

操作步骤

在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

2. 在弹出的对话框中输入包名, 例如 com.bit.demo1

在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了
同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

d 常见的包

java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
java.lang.reflect:java 反射编程包;
java.net:进行网络编程开发包。
java.sql:进行数据库开发的支持包。
java.util:是java提供的工具程序包。(集合类等) 非常重要
java.io:I/O编程开发包。

7.7 static 成员

不加static和使用static区别：
在这里插入代码片

7.7.2 静态修饰成员变量

import java.util.Arrays;import java.util.*; // 通配符的意思，要哪一个就匹配哪一个import java.util.Date;class Student {//构造方法也是可以被封装的只能在当前类当中使用private String name;//private当前成员变量只能在当前类中使用public int age;public static String classRoom;public String getClassRoom() {return classRoom;}public void setClassRoom(String classRoom) {this.classRoom = classRoom;}public Student(String name, int age) {this.name = name;this.age = age;}}public class Test {public static void main(String[] args) {Student.classRoom = "2-201"; // 静态成员变量。类名.访问}public static void main5(String[] args) {Student student1 = new Student("x",10);student1.classRoom="2-201"; // 非静态成员变量。对应的引用.访问Student student2 = new Student("j",11);Student student3 = new Student("h",12);}}

总结：类的成员变量

静态成员变量

属于类的，不属于对象的，只有1份
类名+点号来访问静态成员变量【类名访问合理，而对象来访问不合理】

非静态成员变量/普通成员变量

属于对象的，每次实例化一个对象，都会有一个对应的非静态成员变量，每个对象都有。
对应的引用+点好来访问

注意：静态的成员变量，随着类被加载而创建，类被销毁而销毁。

7.7.4 static修饰成员方法

public static void sleep() {//System.out.println(this.name+" 正在睡觉！");//报错，在静态方法的内部// 不能使用非静态的数据成员 this不能出现在静态方法当中System.out.println(" 正在睡觉！");}public static void main(String[] args) {Student.classRoom = "2-201"; // 静态成员变量。类名.访问/*Student student1 = new Student("zhansan",10);//非静态student1.sleep();*/Student.sleep();//静态}

注意：
在静态方法内部，不能使用非静态的数据成员，this不能出现在静态方法中，反之非静态方法当中可以调用静态方法。
而一个依赖对象的方法，当中可以有不依赖对象的。

7.7.5 static成员变量初始化

静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实列属性。
静态成员变量的初始化分为两种：就地初始化和静态代码块初始化。

就地初始化：在定义时直接给出初始值

public class Student{private String name;private String gender;private int age;private double score;private static String classRoom = "306";}

静态代码块初始化如下：

7.8 代码块

7.8.1 代码块概念以及分类

使用{}定义的一段代码称为代码块。根据代码块定义的位置以及关键字，分为一下四种：

普通代码块
构造块
静态块
同步代码块

7.8.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 = 10x2 = 100

7.8.3 构造代码块

构造块：定义在类中的代码块（不加修饰符）。也叫：实例代码块。构造代码块一般用于初始化实列成员变量。

class TestStatic {public static int staticNum = 100000;public int date1 = 10;{//构造 / 实例 代码块System.out.println("实例代码块执行了");date1 = 1000;// 一般情况下 用来初始化 非静态的数据成员//staticNum = 100;// 也可以初始化静态的数据成员}static {System.out.println("静态代码块执行了");staticNum = 999;}// 先执行静态代码块 后执行实列代码块public static void main(String[] args) {TestStatic testStatic = new TestStatic();System.out.println(testStatic.date1);System.out.println(TestStatic.staticNum);//只要类被加载 就会执行静态代码块}}

注意：

实例代码块一般情况下用来初始化非静态的数据成员，也可以初始化静态的数据。
一定最先执行静态代码块后执行实列代码块
只要类被加载就会执行静态代码块
当都是静态的时候按照定义的顺序执行

7.8.4 静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

class TestStatic {public static int staticNum = 100000;public int date1 = 10;{//构造 / 实例 代码块System.out.println("实例代码块执行了");date1 = 1000;// 一般情况下 用来初始化 非静态的数据成员//staticNum = 100;// 也可以初始化静态的数据成员}// 多个静态代码块在编译时，会按照定义顺序来执行（合并），static {System.out.println("静态代码块执行了");staticNum = 999;}static {staticNum = 888;}// 先执行静态代码块 后执行实列代码块public static void main(String[] args) {TestStatic testStatic = new TestStatic();System.out.println(testStatic.date1);System.out.println(TestStatic.staticNum);//只要类被加载 就会执行静态代码块}}

注意：

静态代码块不管生成多少个对象，其只会执行一次
静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
实例代码块只有在创建对象时才会执行

7.9 内部类

当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么这个内部的完整结构最好使用内部类。在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {class InnerClass{}}// OutClass是外部类// InnerClass是内部类

注意：

定义在class 类名{}花括号外部的，即使是在一个文件里，都不能称为内部类

public class A{}class B{}// A 和 B是两个独立的类，彼此之前没有关系

内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

7.9.1 内部类的分类

先来看下，内部类都可以在一个类的那些位置进行定义

public class OutClass {// 成员位置定义：未被static修饰 -->实例内部类public class InnerClass1{}// 成员位置定义：被static修饰 --> 静态内部类static class InnerClass2{}public void method(){// 方法中也可以定义内部类 --> 局部内部类：几乎不用class InnerClass5{}}}

7.9.2 内部类

实例内部类

即未被static修饰的成员内部类。

class OuterClass {public int data1 = 1;private int data2 = 2;public static int data3 = 3;// 实例内部类class InnerClass {public int data1 = 111;public int data4 = 4;private int data5 = 5;// 常量是在编译的 时候确定的 由final修饰public static final int data6 = 6;public void test(){// 优先访问实例内部类自己的data1= this。nameSystem.out.println(data1);// 如果非要访问外部类的data1System.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);System.out.println("Inner::test()");}}public void func() {InnerClass innerClass = new InnerClass();innerClass.test();}}public class Test {public static void main(String[] args) {OuterClass out = new OuterClass();out.func();OuterClass.InnerClass innerClass = out.new InnerClass();// out.new == new OuterClass().newOuterClass.InnerClass innerClass1 = new OuterClass().new InnerClass();innerClass.test();}}

注意：

外部类中的任何成员都可以在实例内部类方法中直接访问
实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名
称.this.同名成员来访问
实例内部类对象必须在先有外部类对象前提下才能创建
实例内部类的非静态方法中包含了一个指向外部类对象的引用
外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

静态内部类

被static修饰的内部成员类称为静态内部类。

class Outer {public int data1 = 1;private int data2 = 2;private static int data3 = 3;//静态内部类static class InnerClass {public int data4 = 4;public int data5 = 5;public static int data6 = 6;public void test() {System.out.println("InnerClass::test()");// 在静态内部类中是否可以 直接 访问外部类对象 的非静态成员变量？ 不能/*System.out.println(data1); // 比如data1和data2需要通过对象的引用调用System.out.println(data2);*/Outer outer = new Outer();System.out.println(outer.data1);System.out.println(outer.data2);System.out.println(data3); // 是由static修饰的System.out.println(data4);System.out.println(data5);System.out.println(data6);}}public void testFunc() {System.out.println("Outer::testFunc()");}}public class Test {public static void main(String[] args) {//如何获取静态内部类的对象//InnerClass innerClass = new InnerClass(); 不可以//外部类名.内部类名 获得 类型Outer.InnerClass inn = new Outer.InnerClass();inn.test();}}

注意：

在静态内部类中只能访问外部类中的静态成员
创建静态内部类对象时，不需要先创建外部类对象

匿名内部类（以后用的比较多）

interface InterFaceA {void func();}class TestA implements InterFaceA{@Overridepublic void func() {System.out.println("我是重写的funcA方法");}}public class Test {public static void main(String[] args) {new Test() {};}public static void main2(String[] args) {TestA testA = new TestA();testA.func();System.out.println("============");// 一个类 实现了一个接口，并且重写了接口当中的方法InterFaceA a = new InterFaceA() {@Overridepublic void func() {System.out.println("匿名内部类");}};a.func();System.out.println("============");new InterFaceA() {@Overridepublic void func() {System.out.println("匿名内部类");}}.func();}}

7.9.3 局部内部类

定义在外部类的方法体或者{}中，该种内部类只能在其定义的位置使用，就是实例化的时候，只能在方法内部进行实例化。

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
几乎不会使用

7.10 对象的打印

Dog.java

package com.bit.www;public class Dog {// 姓名private String name;// 年龄private int age;// 颜色private String color;public Dog() {}//构造方法用来实例化狗的对象public Dog(String name, int age, String color) {this.name = name;this.age = age;this.color = color;}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 getColor() {return color;}public void setColor(String color) {this.color = color;}public void barks() {System.out.println(this.name+" 在狗叫");}public void eat() {System.out.println(this.name+" 在干饭");}public static void staticFun() {System.out.println("staticFun");}// 打印所有属性public void show() {System.out.println("狗名:"+this.name+" 年龄:"+this.age+" 颜色:"+this.color);}/*public String toString() {String ret = "狗名:"+this.name+" 年龄:"+this.age+" 颜色:"+this.color;return ret;}*/@Override //注解当前这个代码是重写的public String toString() {return "Dog{" +"name='" + name + '\'' +", age=" + age +", color='" + color + '\'' +'}';}}

Test.java

package com.bit.www;import com.bit.demo1.TestDemo;public class Test {public static void main(String[] args) {Dog dog = new Dog();dog.setName("旺财");dog.setAge(4);dog.setColor("黄色");//dog.barks();//dog.eat();//dog.show();System.out.println(dog);//分析 System.out.println(dog);//com.bit.www.Dog@1b6d3586//Dog这个类的路径对象地址的哈希值}}

【0基础学Java第七课】– 类和对象02

7.类和对象02

7.6 封装

7.6.1 封装的概念

7.6.2 访问限定符

7.6.3封装扩展之包

a.包的概念

b. 导入包中的类

c. 自定义包

d 常见的包

7.7 static 成员

7.7.2 静态修饰成员变量

7.7.4 static修饰成员方法

7.7.5 static成员变量初始化

7.8 代码块

7.8.1 代码块概念以及分类

7.8.2 普通代码块

7.8.3 构造代码块

7.8.4 静态代码块

7.9 内部类

7.9.1 内部类的分类

7.9.2 内部类

实例内部类

静态内部类

匿名内部类（以后用的比较多）

7.9.3 局部内部类

7.10 对象的打印

最新关注

热文推荐

零时科技 || TrustSwap 攻击事件分析

Tomcat 入门实战(3)–Https 配置

一文掌握软件项目成本预算、估算的方法和成本控制的秘籍

【机器学习】人工智能概述（文末送书）

Dubbo2.7源码详解

基于JAVA+Springboot+Thymeleaf前后端分离项目：旅游景点景区购票售票系统设计与实现

【0基础学Java第七课】– 类和对象02

7.类和对象02

7.6 封装

7.6.1 封装的概念

7.6.2 访问限定符

7.6.3封装扩展之包

a.包的概念

b. 导入包中的类

c. 自定义包

d 常见的包

7.7 static 成员

7.7.2 静态修饰成员变量

7.7.4 static修饰成员方法

7.7.5 static成员变量初始化

7.8 代码块

7.8.1 代码块概念以及分类

7.8.2 普通代码块

7.8.3 构造代码块

7.8.4 静态代码块

7.9 内部类

7.9.1 内部类的分类

7.9.2 内部类

实例内部类

静态内部类

匿名内部类（以后用的比较多）

7.9.3 局部内部类

7.10 对象的打印

相关文章

最新关注

热文推荐