1. 实例方法和静态方法
注意
1. 同类中可直接通过方法名调用静态static方法，方法名(参数类型 参数)
2. 如果使用条件语句在执行的时候需要兜底，使用两个return
3. 静态方法内部，无法访问this变量，也无法访问实例字段，它只能访问静态变量和静态方法
4. 成员变量私有化从外部改变的解决方式，通过方法 get、set方法来操作
- 实例方法
无返回值
创建语法：[权限修饰符] void 方法名(参数类型 参数) { 执行体 }
使用语法：类的实例化对象.方法名(参数类型 参数);
有返回值
创建语法：[权限修饰符] 返回值数据类型 方法名(参数类型 参数) {执行体 }
使用语法：类的实例化对象.方法名(参数类型 参数);
- 静态方法 static
无返回值
创建语法：[权限修饰符] static 返回值数据类型 方法名(参数类型 参数) {执行体 }
使用语法：类名.方法名(参数类型 参数);
有返回值
创建语法：[权限修饰符] static void 方法名(参数类型 参数) { 执行体 }
使用语法：类名.方法名(参数类型 参数);
2. 方法的重载（同名不同参）
- 在一个类中，可以创建多个同名方法，方法的参数列表不完全相同，返回的参数可相同也可不同。
- 调用方法时会根据传入的参数，自动匹配满足参数条件的那个同名方法，当一个方法可以接受不同的参数
- System.out.println(); 方法就是方法重载，可以接受不同的参数将结果打印在控制台
- 静态方法也可以被重载
public class test {
public static void main(String[] args) {
init(); // 静态方法的使用
}
// 静态方法的创建
public static void init() {
test test_obj = new test();
// 重写方法的智能匹配
System.out.println(test_obj.printLog(1,2.13f));
test_obj.printLog("hello world!");
}
// 方法重载：实例方法的创建，无返回值
public void printLog(int a,int b) {
System.out.println(a + b);
}
// 方法重载：实例方法的创建，有返回值
public float printLog(int a,float b) {
return a + b;
}
// 方法重载
public void printLog(String c) {
System.out.println(c);
}
}
3. 方法的重写（同名同参）
- 在类的继承中，子类可以调用父类的实例方法，同时子类也可以重写父类的实例方法，可以在延续父类方法的基础上重写，也可以完全重写
- 重写方法的参数列表必须相同，返回的数据类型必须相同，否则就变成方法的重载啦
- 静态方法不可以被重写
因为静态方法是类在加载时就被加载到内存中的方法,在整个运行过程中保持不变
实例方法单独申请内存空间,为每一个实例分配独立的运行内存,因而可以重写
public class test {
public static void main(String[] args) {
Children Children = new Children();
System.out.println(Children.getName("子类单独实现"));
}
}
//父类
class Father{
public String getName(String content) {
System.out.println(content);
return "父类";
}
}
//子类继承
class Children extends Father{
public String getName(String content) {
super.getName("父类方法，子类可执行，也可不执行（不调用）");
return "子类：" + content;
}
}
4. 构造方法（构造器）
- 传统的创建对象
将类实例化成对象
步骤：先实例化类，然后再通过给实例化对象赋值的方式创建对象的属性，这就很臃肿
public class Use {
public static void main(String[] args) {
init.printInfo();
}
}
// 初始化
class init {
public static void printInfo() {
Shenshou qinglong = new Shenshou();
qinglong.age = 1000;
qinglong.name = "青龙";
Shenshou baihu = new Shenshou();
baihu.age = 2000;
baihu.name = "白虎";
Shenshou zhuque = new Shenshou();
zhuque.age = 3000;
zhuque.name = "朱雀";
Shenshou xuanwu = new Shenshou();
xuanwu.age = 4000;
xuanwu.name = "玄武";
System.out.println(qinglong.name + " " + qinglong.age);
System.out.println(baihu.name + " " + baihu.age);
System.out.println(zhuque.name + " " + zhuque.age);
System.out.println(xuanwu.name + " " + xuanwu.age);
}
}
// 如果没有在类中创建构造方法，那么在编译的时候会自动生成一个空的无参的构造方法
class Shenshou {
int age;
String name;
}
如果没有在类中创建构造方法，那么在编译的时候会自动生成一个空的无参的构造方法
- 构造方法创建对象
写好构造方法，通过给实例化类穿参就可以创建对象
步骤：
1. 在类中创建构造方法，再创建一个空构造函数（省略此部，将无法通过传统的方式创建对象）
2. 实例化对象，并通过传参的方式给对象属性统一赋值
注意：
1. 一般同时再创建一个空参数的重载方法，否则使用 new Shenshou() 传统创建对象的方式无法使用
2. 构造方法在类中创建，且方法名和类名必须相同
3. 构造方法无返回值，且不需要 void 修饰
4. 构造方法无法像其他方法一样被调用
5. 构造方法也可以方法重载
public class test {
public static void main(String[] args) {
init.printInfo();
}
}
//初始化
class init {
public static void printInfo() {
Shenshou qinglong = new Shenshou(1000,"青龙");
Shenshou baihu = new Shenshou(2000,"白虎");
Shenshou zhuque = new Shenshou(3000,"朱雀");
Shenshou xuanwu = new Shenshou(4000,"玄武");
System.out.println(qinglong.name + " " + qinglong.age);
System.out.println(baihu.name + " " + baihu.age);
System.out.println(zhuque.name + " " + zhuque.age);
System.out.println(xuanwu.name + " " + xuanwu.age);
Shenshou qinglong_ = new Shenshou("1111岁的","青龙");
Shenshou baihu_ = new Shenshou("2222岁的","白虎");
Shenshou zhuque_ = new Shenshou("3333岁的","朱雀");
Shenshou xuanwu_ = new Shenshou("4444岁的","玄武");
System.out.println(qinglong_.info);
System.out.println(baihu_.info);
System.out.println(zhuque_.info);
System.out.println(xuanwu_.info);
}
}
class Shenshou {
int age;
String name;
String info;
// 构造函数（重载1）
public Shenshou(int age, String name) {
this.age = age;
this.name = name;
}
//构造函数（重载2）
public Shenshou(String age, String name) {
this.info = age + " " + name;
}
// 创建一个空的重载方法，这样的话，也可以通过传统的方式创建对象
public Shenshou() {}
}
5. 方法的可变参数
创建方法时需要用参数类型修饰参数，以此限制参数的范围
此功能实现了，在方法中可以传递和接受若干个同类型参数
语法：
传参时决定传几个同类型参数，创建时接受以数组的方式接受若干个参数： 方法名(参数类型...标识符)
注意：
1. 可变参数接受时是一个数组
2. 方法中可以传递多个参数，但是可变参数只能有一组，且必须放在最后
public static void main(String[] args) {
printLog(1,"张三","李四");
printLog(2," ");
printLog(3,"青龙","白虎","朱雀","玄武");
}
public static void printLog(int num, String... args){
for(String item : args) {
System.out.println(item + num);
}
}
