文章目录
封装概述:
1、封装:隐藏事物的属性和实现细节,对外提供公共的访问方式。
2、封装的好处:
隐藏了事物的实现细节
提高了代码的复用性
提高了安全性
3、封装的原则:
隐藏事物的属性
隐藏事物的实现细节
对外提供公共的访问方式
private关键字
1、private单词:私有的
2、可以修饰的内容:
修饰成员变量
修饰成员方法
修饰构造方法
3、修饰之后的效果:
被private修饰的成员,只能在本类中被访问。
4、private关键字的注意事项;
private只是封装的一种体现形式
Getter和Setter
1、当属性被私有之后,外界无法直接访问,所以需要提供公共的访问方式,让外界可以间接的访问属性。对于当前类,就可以控制外界访问属性的方式。(我让你怎么访问,你就只能怎么访问)
2、一般提供get方法,获取成员变量的值、提供set方法,设置成员变量的值
变量访问原则和this关键字
1、变量访问的就近原则:
就近原则:当在访问某个变量名称的时候,会先寻找最近的该变量名称的定义,如果寻找到了,就使用该变量,如果没有找到,才到更远的位置寻找该变量名称的定义。
当局部变量和成员变量同名的时候,一定是先使用局部位置定义的变量,如果没有,才会使用成员位置定义的变量。
2、this关键字:
表示当前类型当前对象的引用
哪个来调用this所在的方法,this就代表哪个对象
作用:用于区分局部变量和成员变量同名的情况。使用this.属性名称的一定是成员变量,没有使用this.的变量,根据就近原则来确定使用哪个变量。
代码示例:
class Student {
private String name;
private int score;
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public void test(String[] args) {
String name;
name = "张三";//指的是局部变量name
}
}
构造方法
构造方法概述
1、构造方法:构造函数,构造器,Constructor
2、作用:用于给对象中的成员变量赋值。在创建对象的同时,会自动调用构造方法,等对象创建完成的时候,对象中的成员变量就已经有指定的值了。
3、构造方法的定义格式:
修饰符 方法名称(参数列表) {
方法体
}
4、构造方法格式的说明:
1、构造方法的方法名称,必须和类名一模一样,连大小写都一样。
2、构造方法没有返回值类型,连void也没有
3、构造方法没有return语句,如果一定需要return语句,就写一个return;
return后面不能跟 内容,加return没有实际的意义。
5、构造方法其他说明:
1、构造方法不需要手动调用,由jvm虚拟机在创建对象的时候自动调用
2、对象本身不能调用构造方法
3、构造方法只调用一次。
构造方法的注意事项
1、构造方法可以是有参数的,也可以是没有参数的
如果是没有参数的构造方法,外界无需传入任何的参数值,只能给成员变量赋固定值或者不赋值
如果是有参数的构造方法,外界在调用构造方法的时候,需要传入实际的参数值,用于赋值给成员变量。
2、如果在类中没有定义任何的构造方法,那么系统会自动提供一个空参构造(空实现)
3、如果在类中手动定义了一个构造方法(无论是空参还是有参),系统都不再会提供任何的构造方法。
4、构造方法的重载:
在同一个类中,方法名相同,参数列表不同,与返回值类型无关
构造方法和set方法的比较
1、构造方法和set方法都是用于给成员变量赋值。二者都不希望外界直接访问私有成员变量,通过构造方法或者set方法,间接的访问私有变量。
2、区别:
构造方法是在创建对象的同时,由jvm自动调用执行,用于给属性赋值,只能执行一次
set方法是在创建对象之后,由对象手动调用执行,用于给属性修改值,可以调用多次
3、使用场景比较:
一般set方法使用更加灵活,使用更加频繁
构造方法,只能在创建对象的时候被自动调用一次,代码更加简洁。一旦对象创建成功,就不能继续使用构造方法修改成员变量的值。
静态
静态概述:
1、没有静态:如果某个类型的所有对象,都具有一个相同的属性值,比如2个对象的age都是23;
那么这个属性值就没有必要在所有对象中,都存储一份。
坏处:浪费内存空间;维护难度大,一旦需要修改,就得修改所有的对象。
无静态代码示例:
public class Test01 {
public static void main(String[] args) {
Actor a1 = new Actor();
a1.name = "张三";
a1.country = "中国";
System.out.println(a1.name + "..." + a1.country);
Actor a2 = new Actor();
a2.name = "李四";
a2.country = "中国";
System.out.println(a2.name + "..." + a2.country);
//二者都来自中国
}
}
class Actor {
String name;
String country;
}
2、有静态的状态:如果某个类型的所有对象,都具有一个相同的属性值,那么就在这个属性的定义上,加一个static静态关键字。让该变量存储在方法区字节码的静态区中,避免了所有对象都存储相同数据的问题,节省了内存空间,将来维护容易(只需要修改一次)
有静态代码示例:
/**
* 有静态代码示例
*/
public class Simple02 {
public static void main(String[] args) {
Actor1 a1 = new Actor1();
a1.name = "张三";
a1.country = "中国";
System.out.println(a1.name + "..." + a1.country);//张三 中国
Actor1 a2 = new Actor1();
a2.name = "李四";
a2.country = "中国";
System.out.println(a2.name + "..." + a2.country);//李四 中国
Actor1.country = "法国";
System.out.println(a1.name + "..." + a1.country);//张三 法国
System.out.println(a2.name + "..." + a2.country);//李四 法国
}
}
class Actor1 {
String name;
static String country;//加上static关键字
}
静态变量的特点
1、静态的解释:static关键字
静态、静止的。静态变量不会随着对象的变化而变化
2、加载时机:
随着类的加载而加载。
静态变量随着类的加载进方法区,就直接在静态区给开辟了存储静态变量的内存空间
3、静态变量优先于对象而存在
4、静态变量被所有该类对象所共享
5、代码层面:可以使用类名直接调用,不需要使用对象名称。在不创建对象的前提下,仍然可以使用这个静态变量。建议使用类名来访问。
静态访问的注意事项
1、静态方法:在方法声明上,加上了static关键字的方法,就是静态方法
2、静态方法不能访问非静态的变量
原因:静态方法本身可以在没有创建对象的时候调用;非静态的变量只有在对象创建之后才存在。如果静态方法可以访问非静态的变量,那么就相当于在对象创建之前,就访问了对象创建之后的数据。明显不合理。
3、静态方法不能访问非静态的方法
原因:静态方法可以在没有创建对象的时候调用;非静态的方法可以访问非静态的变量。如果静态方法可以访问非静态的方法,就相当于静态方法间接的访问了非静态的变量
4、静态方法中不能存在this关键字
原因:this关键字表示本类当前对象。静态方法可以在对象创建之前调用。如果静态方法可以访问this关键字,相当于在创建对象之前,就使用了对象本身。矛盾。
5、总结:
静态不能访问非静态
静态变量和非静态变量的区别
1、概念上,所属不同:
非静态变量属于对象
静态变量属于类,类变量
2、内存空间不同,存储位置不同
非静态变量属于对象,所以存储在堆内存中
静态变量属于类,存储在方法区的静态区中
3、内存时间不同,生命周期不同
非静态变量属于对象,所以生命周期和对象相同,随着对象的创建而存在,随着对象的消失而消失
静态变量属于类,所以生命周期和类相同,随着类的加载
4、访问方式不同
非静态变量只能使用对象名访问
静态变量既可以使用对象访问,也可以通过类名访问:
类名.静态变量名
类名.静态方法名()
工具类
工具类的编写
1、工具类:在一个类中,没有维护什么数据,没有任何的成员变量,相当于是一个工具。类中就都是一些静态方法,快速的解决一些常见的问题。
2、名称:ArrayTool
3、作用:可以提供操作数据的各种方法
4、功能:
数组的遍历
获取数组的最大值
获取数组的最小值
数组元素反转
5、方法都是静态的,不需要创建对象;创建对象会浪费系统资源。希望控制不让创建对象。
方式:使用构造方法私有化
代码示例:
public class ArraysUtil
// 1、循环打印数组
public static void print(int[] arr) {
for (int i = 0; i < arr.length; i++) {
if (arr != null) {
System.out.print(arr[i] + ",");
}
}
}
// 2、循环打印数组,一行打印指定个数的元素
public static void print(int[] arr, int number) {
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + ",");
if ((i + 1) % number == 0) {
System.out.println();// 换一行
}
}
}
// 3、将数组转成[元素1,元素2...]这种格式的字符串
public static String formatPrint(int[] arr) {
if (arr == null)
return "null";
int iMax = arr.length - 1;// 如果iMax是-1 意味着数组长度是0
if (iMax == -1)
return "数组长度为0";
StringBuilder b = new StringBuilder();//
b.append('[');// 在最前方追加一个[
for (int i = 0;; i++) {
b.append(arr[i]);
if (i == iMax) {// 满足条件 就退出
return b.append(']').toString();
}
b.append(", ");
}
}
// 4、将数组冒泡\或者其他算法排序(直接将原数组排序)
public static void sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int desk = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = desk;
}
}
}
}
// 5、将数组冒泡\或者其他算法排序(不允许排形参的数组,需要直接返回一个排好序的新数组)
public static int[] sortNew(int[] arr) {
int arrNew[] = new int[arr.length];
// 把源数组 内容赋值一份给 arrNew
// arrNew = Arrays.copyOf(arr, arr.length);
for (int i = 0; i < arrNew.length; i++) {
arrNew[i] = arr[i];
}
for (int i = 0; i < arrNew.length - 1; i++) {
for (int j = 0; j < arrNew.length - 1 - i; j++) {
if (arrNew[j] > arrNew[j + 1]) {
int desk = arrNew[j];
arrNew[j] = arrNew[j + 1];
arrNew[j + 1] = desk;
}
}
}
return arrNew;
}
// 6、比较两个数组的所有元素是否完全一致
public static boolean isEquals(int[] arr1, int[] arr2) {
if (arr1 == arr2)// 地址相同 里面的数据肯定相同
return true;
if (arr1 == null || arr2 == null)
return false;
int length = arr1.length;
if (arr2.length != length)
return false;
for (int i = 0; i < length; i++)
if (arr1[i] != arr2[i])
return false;
return true;
}
// 7、计算数组的平均值
public static double avg(int[] arr) {
double sum = 0;
for (int i = 0; i < arr.length; i++) {
sum += arr[i];
}
return sum / arr.length;
}
// 8、计算数组的最大值
public static int max(int[] arr) {
int maxnumber = arr[0];// 数组第一个 为最大值
for (int i = 1; i < arr.length; i++) {
if (maxnumber < arr[i]) {
maxnumber = arr[i];
}
}
return maxnumber;
}
// 9、计算数组的最小值
public static int min(int[] arr) {
int minnumber = arr[0];// 数组第一个 为最小值
for (int i = 0; i < arr.length; i++) {
if (minnumber > arr[i]) {
minnumber = arr[i];
}
}
return minnumber;
}
// 10、将一个数组的所有元素都反转(比如{5,4,8}变成{8,4,5})
public static int[] reverse(int[] arr) {
int[] arrNew = new int[arr.length];
for (int x = 0; x < arr.length; x++) {
arrNew[x] = arr[arr.length - 1 - x];
}
return arrNew;
}
// 11、判断一个指定的数值在数组中是否存在
public static boolean isExits(int[] arr, int number) {
boolean isTrue = false;
for (int i = 0; i < arr.length; i++) {
if (arr[i] == number) {
return true;
}
}
// 如果不存在
return false;
}
}