一.构造方法
对成员变量进行 初始化
写法:关键词 类名(){}
注意:构造方法没有返回值,并且连写返回值的位置都没有
构造方法是系统调用的,并且每创建一个对象,他的构造方法就只会调用一次
构造方法有:无参构造方法和有参构造方法
代码实例:
//如果没有(无参)构造方法,那么系统会给你提供一个无参的构造方法
//如果你写了有参的构造方法,那么系统就不会给你提供无参的构造方法了
//注意:一般写类时,都会手写有参和无参的构造方法
//构造方法是系统调用的,并且构造方法只会调用一次
/*
类的书写顺序:
1.成员变量
2.构造方法
3.set/get方法
4.成员方法
*/
public class Kll {
public static void main(String[] args) {
Car car = new Car();
car.sayHi();
//系统会根据你传入的参数,来选择调用哪儿个构造方法
Car c1 = new Car("博基尼", "亮红");
c1.sayHi();
}
}
class Car{
private String name;
private String color;
//构造方法
//无参的构造方法
public Car() {
name = "奥迪双钻";
color = "红色";
System.out.println("无参的构造方法");
}
//有参的构造方法(创建对象时,给成员变量初值)
//构造方法的重载 和 函数重载一样 可以重名
public Car(String name,String color) {
this.name = name;
this.color = color;
System.out.println("有参的构造方法");
}
// set/get方法
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setColor(String color) {
this.color = color;
}
public String getColor() {
return color;
}
// 介绍自己的方法
public void sayHi() {
System.out.println(name + " " + color);
}
}
二.静态变量
静态变量(类变量)(共享变量,被所有对象共享)
关键词 static (修饰成员变量/成员方法)
好处:可以节省内存空间
静态变量的调用
1.使用对象.变量名调用(不推荐使用)
2.直接使用类名调用(系统推荐)
为什么系统推荐使用类名调用静态变量?
更好的区分 成员变量和 静态变量
成员变量和静态变量的区别:
1.调用的方式
成员变量: 对象调用
静态变量: 对象 和 类名(推荐)都能调用
2.内存中的表现
成员变量: 在堆内存中
静态变量: 在方法区的静态区
3.所属不同
成员变量: 属于对象的
静态变量: 属于类的(不依赖于对象的创建)
4.生命周期
成员变量: 随着对象的创建而创建,随着他的销毁而销毁
静态变量: 随着类的创建而创建 程序结束时销毁
注意:类是优先对象存在的
描述一下下面代码在内存中的表现:
1. 加载main函数所在的类的.class文件
Demo04.class 加载进入方法区
2. 创建AVGirl对象 先把AVGirl.class加载
3. 在堆内存中创建AVGirl对象
该内存中保存了 成员变量
把系统分配的内存地址 返回给 girl1 保存
4. 通过girl1赋值成员变量
5. 通过类名赋值静态变量
6. sayHi() 方法入栈 打印 出栈
7. main 执行完毕
8. 程序结束
代码实例:
public class Kll {
public static void main(String[] args) {
girl girl1 = new girl();
girl1.girlName = "苍老师";
girl1.nationality = "日本";
girl1.sayHi();
girl1.nationality = "泰国";
girl girl2 = new girl();
girl2.girlName = "岛田庄司";
//girl2.nationality = "日本";
girl2.sayHi();
girl1.sayHi();
}
}
class girl{
String girlName;
//static修饰的变量,会存在方法区的静态区
static String nationality;//国籍
public void sayHi() {
System.out.println(girlName+" "+nationality+" ");
}
}
三.静态方法
静态方法调用:
1.对象调用(不推荐)
2.直接使用类名调用(推荐)
总结:静态的只能使用静态的(指成员变量和成员方法,具体意思请看代码注释)
public class Kll {
public static void main(String[] args) {
//new Test().fun2();
//调用这个静态方法时
Test.fun2();
}
}
class Test{
int number1 = 10;
static int number2 = 20;
/*
成员方法中 可以使用成员变量,也可以使用静态变量
成员方法中 可以使用静态变量吗?
可以
成员方法中 可以调用成员方法和静态方法
静态方法不能调用成员方法,但是可以调用静态方法
这是程序的执行顺序有关,因为在程序执行时,方法区加载方法时会被加载进入静态区,而成员方法和变量需要创建对象时才能够执行.
*/
public void fun1() {
System.out.println(this.number1);
System.out.println(Test.number2);//静态变量最好使用类名调用
//本类中调用自己的方法可以省略this或类名
Test.fun2();
}
/*
静态方法(类方法)(也是进栈执行)
什么时候加载进内存?
静态变量一样,被加载到方法区的静态区
静态方法也是随着类的加载而加载
静态方法中能不能使用成员变量?
注意:静态方法中,不能使用成员变量,静态方法被加载时,还没有对象产生
注意也不能使用 this关键字
*/
public static void fun2() {
//System.out.println(number1);
System.out.println(Test.number2);
Test.fun3();
}
public static void fun3() {
//System.out.println(number1);
System.out.println(Test.number2);
}
}
四.主函数main解析
/*
mian方法解析:
public :表示使用权限(公开的)
static :JVM(虚拟机)可以直接使用类名调用main方法
void :放回值类型
main :不是关键字,但是名字不能换;因为JVM(虚拟机)运行代码时,就是找类中main这个静态方法
String[] args 可以接收用户的输入
整个main所有的词都不能换,只有args名可以换[但是一般不会去更改名字]
*/
public class Kll {
public static void main(String[] args) {
//查看数组长度
System.out.println(args.length);
//查看数组内容
// System.out.println(Arrays.toString(args));
for (int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
#### 五.工具类创建
制作文档格式:
javadoc -d(生成文档的路径) -version(版本) -author 文件名.java
/*
封装一个数组工具类,制作文档
当一个类中全是静态方法,这时可以私有化构造方法(因为用不上对象)
一般工具类都会这样 私有化创造方法
制作文档
javadoc -d(生成文档的路径) -version(版本) -author 文件名.java
*/
public class ArrayToolTest {
public static void main(String[] args) {
//参数引用数据类型,传入的是地址
//方法中操作这个地址,相当于操作的是原数组
int[] arr = {3, 5, 2, 1};
ArrayTool.sort(arr);
ArrayTool.printArray(arr);
}
}
工具类创建代码:
/**
* 数组工具类
* 获取数组最大值
* 打印数组
* 数组反转
* 选择排序
* */
public class ArrayTool {
/**
* 构造方法私有化
*/
private ArrayTool() {
}
/**
* 获取数组中的最大值
* @param arr 传入的参数
* @return 返回数组最大值
*/
public static int findArrayMax(int[] arr) {
int max = arr[0];
for (int i = 0; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
}
/**
* 打印数组
* @param arr 传入的参数
*/
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
/**
*
* @param arr 传入的参数
* @param arr1 传入的参数
*/
public static void reverse(int[] arr,int[] arr1) {
arr1 = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr1[arr.length - 1 - i] = arr[i];
}
}
/**
* 选择排序
* @param arr 传入的参数
*/
public static void sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = i + 1; j < arr.length; j++) {
if(arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
}
}