08_代码块丶继承和final

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

}

}