Day07笔记
课程内容
1、封装
2、静态
3、工具类
4、Arrays工具类
封装
概述
1、封装：隐藏事物的属性和实现细节，对外提供公共的访问方式
2、封装的好处：
隐藏了事物的实现细节
提高了代码的复用性（同一段代码的多次使用的程度）
提高了数据的安全性
3、封装的原则：
所有的属性都要隐藏
实现细节要隐藏
对外提供公共的访问方式
代码示例
class Demo01_封装概述 {
public static void main(String[] args) {
test();
}
public static void test() {
int a = 10;
a = 20;
a++;
}
}
private关键字
1、单词：私人的，私有的，私密的
2、可以修饰：
成员变量、成员方法、构造方法、内部类
3、效果：
所有被private关键字修饰的成员，只能在本类中被访问
4、private是封装的一种体现形式，并不代表封装的全部，只是封装中最严格的一种表现
代码示例
class Demo02_private {
public static void main(String[] args) {
Person p = new Person();
//p.name = "zhangsanfeng";
//p.age = 123;
p.speak();
}
}
class Person {
private String name;
private int age;
public void speak() {
System.out.println(name + "..." + age);
}
}
get和set方法
1、当属性被隐藏之后，就无法在外界直接访问了，如果不提供公共的访问方式，那么定义这些私有的成员变量，就没有任何意义了
2、set方法是用于给成员变量赋值；get方法用于获取成员变量的值
代码示例
class Demo03_getset {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三疯");
p.setAge(-123);
System.out.println(p.getName() + "..." + p.getAge());
}
}
class Person {
private String name;
private int age;
//提供修改name的set方法
public void setName(String n) {
name = n;
}
//提供获取name的get方法
public String getName() {
return name;
}
//提供修改age的set方法
public void setAge(int a) {
if (a >= 0) {
age = a;
} else {
throw new RuntimeException("请回到火星上");
}
}
//提供获取age的get方法
public int getAge() {
return age;
}
}
变量的访问原则和this关键字
1、变量就近原则：
变量的声明：在内存中，开辟一段存储变量的空间，带着数据类型
变量的使用：获取这个空间中的值，或者给这个空间赋值，不带数据类型
一个变量身份：是局部变量还是成员变量，完全取决于这个变量声明的位置
如果在一个方法中，使用一个变量，那么首先在当前方法中，查找该变量的声明，如果找到了，优先使用当前方法中声明的这个变量；如果没有找到，就到当前类的成员位置寻找该变量的声明；如果在当前类的成员位置上，也没有找到，就到当前类的父类中去寻找。从近到远依次寻找该变量名称的声明，找到之后，就使用这个变量。
2、this关键字：
含义：表示本类当前对象的引用
解释：哪个对象来调用this所在的方法，this就表示哪个对象
作用：可以区分局部变量和成员变量重名的情况
说明：加上this的一定是成员变量，不加this的根据就近原则来判断
代码示例
class Demo04_getset {
public static void main(String[] args) {
Person p = new Person();
p.setName("张三疯");
p.setAge(123);
System.out.println(p.getName() + "..." + p.getAge());
Person p2 = new Person();
p2.setName("李四光");
p2.setAge(124);
System.out.println(p2.getName() + "..." + p2.getAge());
}
}
class Person {
private String name;
private int age;
//提供修改name的set方法
public void setName(String name) {
this.name = name;
}
//提供获取name的get方法
public String getName() {
return name;
}
//提供修改age的set方法
public void setAge(int age) {
if (age >= 0) {
this.age = age;
} else {
throw new RuntimeException("请回到火星上");
}
}
//提供获取age的get方法
public int getAge() {
return age;
}
}
构造方法的概述
1、构造方法：构造器，Constructor
2、作用：用于给成员变量赋值的一个方法。在创建对象的同时，就能给当前对象的成员变量赋值，等对象一创建完成，就已经有合理的属性值了。
3、构造方法定义格式：
1、构造方法的方法名称，必须和类名一模一样
2、构造方法没有返回值类型，连void也没有
3、所以不能有具体的返回内容
4、构造方法调用的说明：
1、构造方法不需要你手动调用，在创建对象的时候，由jvm自动调用
2、对象本身不能调用构造方法
3、构造方法只会在创建对象的时候，调用一次
代码示例
class Demo05_构造方法 {
public static void main(String[] args) {
Person p = new Person();
//p.Person();
p.speak();
}
}
class Person {
private String name;
private int age;
public Person() {
//System.out.println("构造方法被调用了");
name = "zhangsanfeng";
age = 123;
}
public void speak() {
System.out.println(name + "..." + age);
}
}
构造方法的注意事项
1、构造方法可以是有参数的，也可以是没有参数的
空参的构造方法，无法接受外界传入的数据，只能给成员变量赋固定的值
有参数的构造方法，可以接受外界传入的数据，可以根据外界传入的数据的不同，给成员变量赋不同的值
2、如果你没有手动的提供任何的构造方法，系统默认提供一个空参构造，空实现
3、如果你手动提供了任何一个构造方法，系统将不再提供任何构造方法
4、一般在类型中，既需要空参构造，也需要有参构造，需要都手动定义出来，形成了构造方法的重载
5、构造方法的重载：
方法重载：在同一个类中，方法名相同，参数列表不同，与返回值类型无关
构造方法重载；在同一个类中，方法名和类名一模一样，参数列表不同（空参和有参），构造方法没有返回值类型，所以肯定也和返回值类型无关
代码示例
class Demo06_构造方法的注意事项 {
public static void main(String[] args) {
Person p = new Person("lisiguang", 124);
p.speak();
Person p2 = new Person("wanglaowu", 125);
p2.speak();
Person p3 = new Person();
p3.speak();
}
}
class Person {
private String name;
private int age;
public Person() {
//System.out.println("构造方法被调用了");
//name = "zhangsanfeng";
//age = 123;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public void speak() {
System.out.println(name + "..." + age);
}
}
构造方法和set方法的区别
1、构造方法和set方法都可以给成员变量赋值，都是可以让外界简介的访问私有的成员变量。
2、不同点：
1、构造方法在对象创建的时候调用，set方法是在对象创建完成之后调用
2、构造方法由虚拟机自动调用，set方法是由对象调用
3、构造方法只能调用一次，用于给成员变量赋初始化值，set方法可以调用多次，用于 给成员变量修改值
3、使用场景的比较：
1、如果需要在创建对象的时候，给对象赋一个初始化值，使用构造方法
2、如果需要在后期频繁修改成员变量，就使用set方法
代码示例
class Demo07_构造方法和set方法 {
public static void main(String[] args) {
Person p = new Person("zhaoliu", 26);
p.speak();
p.setAge(27);//在原有对象的基础上，修改年龄属性
p.speak();
//创建一个新的对象，将地址复制给p这个引用
//p不指向原来的老对象了，原来的对象就变成了垃圾，很快被回收掉
//这种方式不是修改年龄，而是杀人
p = new Person("zhaoliu", 28);
p.speak();
}
}
创建对象的内存解释
1、创建对象的过程中，会给成员变量进行3次初始化的赋值，分别是：
默认初始化：给成员变量赋默认的初始化值
显式初始化：在定义成员变量的时候，就给成员变量赋相同的初始化值
构造方法初始化：在调用构造方法的时候，根据构造方法的实际参数的值，给成员变量赋值
显式初始化在后，默认初始化在前
显式初始化在前，构造方法初始化在后
2、创建对象的过程总结：
1、将要创建的对象所属的类，加载到方法区
2、在栈内存中，创建该类型的引用
3、在堆内存中，开辟一块存储空间，用于存储该对象的数据
4、默认初始化赋值
5、显式初始化赋值
6、构造方法初始化赋值
7、将对象的地址，赋值给栈内存中的引用
3、图示：
代码示例
class Demo08_创建对象的内存理解 {
public static void main(String[] args) {
Student stu = new Student("zhouqi", 27);
//Student stu = new Student();
stu.speak();
}
}
class Student {
private String id = "9527";
private int score = 66;
public Student() {}
public Student(String id, int score) {
this.id = id;
this.score = score;
}
public void speak() {
System.out.println(id + "..." + score);
}
}
静态
静态的概述
1、没有静态的情况：
同一个country属性，相同的值，在不同的对象中，存储了很多份，浪费内存空间
在维护这个项目时，如果需要修改country属性的值为Japan，所有对象的country属性都需要修改
图示：
2、有静态的情况
相同的一个属性没有存储到堆内存的对象中，而是存储到了类的字节码中
所有的对象都可以访问类的字节码中的静态变量
图示：
代码示例1
class Demo09_没有静态的情况 {
public static void main(String[] args) {
Actor a1 = new Actor();
a1.name = "苍老师";
a1.country = "日本";
a1.act();
Actor a2 = new Actor();
a2.name = "加藤老师";
a2.country = "日本";
a2.act();
}
}
class Actor {
String name;
String country;
public void act() {
System.out.println(name + "..." + country);
}
}
代码示例2
class Actor {
String name;
static String country;
public void act() {
System.out.println(name + "..." + country);
}
}
class Demo10_有静态的情况 {
public static void main(String[] args) {
Actor a1 = new Actor();
a1.name = "苍老师";
a1.country = "日本";
a1.act();
Actor a2 = new Actor();
a2.name = "加藤老师";
a2.country = "日本";
a2.act();
a2.country = "倭";
a2.act();
a1.act();
}
}
静态变量的特点
1、加载的时机：加载，就是开辟内存空间并且赋值
随着类的加载而加载
2、优先于对象存在
3、静态变量被所有该类对象共享
4、代码方面：
静态变量属于类，可以使用类名直接访问，也可以使用对象名访问。建议使用类名访问
格式：类名.静态变量名
代码示例
class Demo11_静态变量的特点 {
public static void main(String[] args) {
BjJava0114Student.manager = "zq";
BjJava0114Student.teacher = "lc";
BjJava0114Student stu1 = new BjJava0114Student();
stu1.name = "zhangsan";
//stu1.manager = "zq";
//stu1.teacher = "lc";
BjJava0114Student stu2 = new BjJava0114Student();
stu2.name = "lisi";
System.out.println(stu2.name + "..." + stu2.manager + "..." + stu2.teacher);
}
}
class BjJava0114Student {
String name;
String id;
String gender;
int score;
static String manager;
static String teacher;
}
静态方法
1、静态变量和静态方法：
静态变量：变量属于类，不会随着对象的不同而不同，静止不变的状态，称为静态
静态方法：方法属于类，不会随着对象的改变而改变运行内容，静止不变的执行内容
2、静态方法：
加上了static关键字的方法，就是静态方法
3、静态方法的访问方式：
和静态变量相同，既可以使用对象名来访问，也可以使用类名访问
4、静态方法访问的注意事项：
1、静态方法不能访问非静态的变量，原因：
静态方法可以在没有创建对象的时候就使用类名来访问
非静态变量必须在创建对象之后才存在
如果静态方法可以访问非静态变量，就相当于在创建对象之前就可以访问创建对象 之后才有的数据
明显有矛盾
2、静态方法不能访问非静态方法，原因：
静态方法可以在没有创建对象的时候直接使用类名访问
非静态方法可以访问非静态变量
如果静态方法可以访问非静态方法，就相当于简介的让静态方法访问了非静态的变 量
刚才已经说过，静态方法不能访问非静态变量。有矛盾
3、静态方法不能访问this关键字，原因：
this关键字属于非静态的内容，对象创建成功之后，才有的数据
静态方法可以在对象创建之前调用。
5、总结：
静态不能访问非静态
代码示例
class Demo12_静态方法的注意事项 {
public static void main(String[] args) {
Test t = new Test();
t.test1();
}
}
class Test {
int a = 10;
public static void test1() {
//System.out.println(a);
test2();
}
public void test2() {
System.out.println(666);
}
}
静态变量和非静态变量的区别
1、概念：所属不同
非静态变量属于对象，对象变量
静态变量属于类，类变量
2、内存：空间存储地址不同
非静态变量属于对象，存储在堆内存的对象中
静态变量属于类，存储在方法区的字节码对象中
3、内存：时间存储长短不同，生命周期不同
非静态变量属于对象，随着对象的创建而存在，随着对象变成垃圾被回收而消失
静态变量属于类，随着类的加载（运行某个类、创建某个类的对象、调用某个类的静态方法、反射方式、加载某个子类的时候父类也会被加载）而加载，随着类的消失而消失
4、代码：访问方式不同
非静态变量只能使用对象名来访问
静态变量既可以使用对象名访问，也可以使用类名访问，建议使用类名访问
类名.静态变量名
类名.静态方法名()
主方法解释
1、主方法：
public static void main(String[] args) {
}
2、public：
公有的，公共的，在任何位置都可以访问这个方法
主方法是被jvm虚拟机调用的，其他语言在调用java代码，需要最大的访问权限
3、static：
静态的，不需要创建主方法所在类的对象，也可以访问这个方法
C语言不会去直接创建对象，访问某个方法，所以只能访问静态的方法
4、void：
方法的返回值类型为空，不需要给jvm返回一些数据，即使返回了一些数据，没用
5、main：
方法名称，必须写成main，因为在jvm虚拟机中，写死了就是要访问main方法
6、String[] args：
主方法的形式参数，是字符串类型的数组，数组中的每一个元素都是一个字符串
代码示例
class Demo13_主方法的解释 {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++) {
System.out.print(args[i] + " ");
}
System.out.println();
}
}
工具类
工具类的编写
1、工具类的定义：没有数据、只有方法的类
定义了一个类，类中都是一些具有某些独立功能的方法
不会使用这个类创建对象
类中不会定义任何的成员变量
2、操作数组的工具类：ArrayTool
3、作用：能提供操作数组的各种方法
4、功能：
遍历数组
获取最大值
获取最小值
数组某两个元素的交换
数组的反转
5、私有化构造方法：
这类是工具类，没有成员变量和其他数据，所以不需要创建对象
私有化构造方法，避免创建对象浪费内存空间
private ArrayTool() {}
帮助文档的制作
1、帮助文档：
写好了代码之后，编译生成ArrayTool.class的字节码文件
给了使用者，使用者无法阅读其中的代码的，也就不知道里面有哪些功能
需要给使用者提供一个帮助文档
2、加上文档注释：【重点】
1、文档注释：用于生成帮助文档的注释
/**
文档注释的内容
*/
2、文档注释中的注解：被编译器和jvm识别和运行的一些内容
@author 作者
@version 版本号
@param 参数名称 参数意义解释
@return 返回的数据的含义
3、使用javadoc生成帮助文档：
javadoc -d ./doc -author -version ArrayTool.java
代码示例1
/**
一个数组的工具类，提供了很多操作数据的实用方法
@author lc
@version v1.0
*/
public class ArrayTool {
private ArrayTool() {}
/**
用于遍历数组
@param arr 需要遍历输出的数组名称
*/
public static void printArr(int[] arr) {
for(int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
System.out.println();
}
/**
获取数组的最大值
@param arr 需要获取最大值的数组
@return 参数数组中的最大值
*/
public static int getMax(int[] arr) {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
return max;
}
/**
获取数组的最小值
@param arr 需要获取最小值的数组
@return 参数数组中的最小值
*/
public static int getMin(int[] arr) {
int min = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] < min) {
min = arr[i];
}
}
return min;
}
/**
交换指定数组中，指定的两个索引的元素
@param arr 需要交换元素的数组
@param a 第一个元素的索引
@param b 第二个元素的索引
*/
public static void swap(int[] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/**
反转数组
@param arr 需要反转的数组
*/
public static void reverse(int[] arr) {
for (int i = 0, j = arr.length - 1; i < j; i++, j--) {
swap(arr, i, j);
}
}
}
代码示例2
class Demo14_ArrayToolTest {
public static void main(String[] args) {
int[] arr = {66, 22, 88, 99, 11, -66};
ArrayTool.printArr(arr);
System.out.println("最大值：" + ArrayTool.getMax(arr));
System.out.println("最小值：" + ArrayTool.getMin(arr));
ArrayTool.swap(arr, 0, arr.length - 1);
ArrayTool.printArr(arr);
ArrayTool.reverse(arr);
ArrayTool.printArr(arr);
ArrayTool at = new ArrayTool();
}
}
帮助文档的使用
1、帮助文档：
将来很少生成帮助文档，但是频繁使用别人制作好的帮助文档
2、使用：在线文档、离线文档
1、在线文档：
百度api
找到jdk中文版
根据要使用的类型，推断在哪个包中
到这个包中寻找你要使用的类型
观察包、是否是抽象类、工具类，阅读信息
根据自己需要使用的功能，查找需要的方法
找到方法之后，阅读方法介绍，进行测试
2、离线文档：
直接打开
点击显示----索引----输入要查询的类型
代码示例
class Demo15_工具类的使用 {
public static void main(String[] args) {
//生成一个1-100的随机数
double a = Math.random();//0.00000-0.999999
double b = 100 * a;//0.00000-99.99999
int c = (int)b;//0-99
int d = c + 1;//1-100
System.out.println(d);
}
}
Arrays工具类
1、Arrays工具类：
提供了很多操作数组的实用方法
2、功能：
1、int binarySearch(int[] arr, int key)：使用二分查找的方式，返回key在arr中的索引
2、boolean equals(int [] arr1, int[] arr2)：比较两个数组中的元素是否相同
3、void fill(int[] arr, int value)：将arr数组中的所有位置为填充为value值
4、void sort(int[] arr)：将arr进行从小到大的排序
5、String toString(int[] arr)：将arr中的内容以字符串的形式进行返回
代码示例
import java.util.Arrays;
class Demo16_Arrays工具类 {
public static void main(String[] args) {
int[] arr = {11, 33, 66, 88, 99};
System.out.println(Arrays.binarySearch(arr, 88));
int[] arr2 = {11, 88, 99, 66, 33};
System.out.println(Arrays.equals(arr, arr2));
int[] arr3 = {11, 33, 66, 88, 99};
System.out.println(Arrays.equals(arr, arr3));
Arrays.fill(arr3, 666);
ArrayTool.printArr(arr3);
Arrays.sort(arr2);
ArrayTool.printArr(arr2);
System.out.println(arr2);
System.out.println(Arrays.toString(arr2));
}
}