类和对象_2
4.7.Java类中方法的表现形式及其基本特征？
Java类中方法是为了描述具有共同性质的一组数物的基本功能/行为。
1.实例方法格式
访问限制修饰符 方法的返回值数据类型 方法的名称（参数列表）{方法体}
(1)访问限制修饰符---public 缺省的
(2)方法的返回值数据类型
返回值-----方法执行结果;
数据类型---基本数据类型【复合数据类型】;
有返回值---方法体中的最后一句话是“return”,方法的返回值数据类型一定是结果值的具体数据类型;
没有返回值---方法体中的没有“return”,方法的返回值数据类型void代替;
(3)方法的名称---合法的标识符【首字母小写，从第二个单词开始首字母大写】
(4)参数列表
参数----引入本方法以外的数据进入本方法进行运算【找帮手】局部变量
列表----可以有多个
没有参数的时候--（）中的内容是空的
(5)方法体--方法的身体【具体执行代码】
例如：
public class Test1{
//没有返回值，没有参数的方法
public void method1(){ }
//有返回值【int】，没有参数的方法
public int method2(){
return 5;
}
//没有返回值，有一个int参数的额方法
public void method3(int int1){}
//有返回值[char]，有一个int参数和一个char参数的方法
public char method4(int int2,char char1){
return 'H';
}
}2.静态方法格式
实例方法的访问限制修饰符后面加上static关键字的方法就是静态方法【类方法】
没有static关键字的方法就是实例方法
例如：
public class Test2{
//2.静态方法
//没有返回值，没有参数的静态方法
public static void method1(){}
//有返回值int，没有参数的静态方法
public static int method2(){
return 10;
}
//没有返回值，有一个int参数的静态方法
public static void method3(int int1){}
//有返回值String型，有一个int参数和一个String参数的静态方法
public static String method4(int int2,String name){
return "zhangsan";
}
}3.构造方法格式
实例方法格式中去掉方法的返回值数据类型，方法的名称是类名这种方法就叫构造方法。
例如：
public class Person{
public Person(){ } --- 无参数的构造方法
public Person(int num){ } --- 有一个int型参数的构造方法
public Person(UserBean user){ } ---有一个UserBean 型参数的构造方法
public Person(UserBean user,int num,char value){}
}构造方法作用就是将来为了创建对象用的。当一个类创建好以后，会有一个默认的无参数构造方法存在，只是没有显式写出罢了。当这个类中出现一个有参数的构造方法时，我们就需要将这个默认的无参数构造方法显式写出,如果没有显式写出这个默认的无参数构造方法，那么这个默认的无参数构造方法将会被有参数的构造方法覆盖。
public class Student{
//存在一个默认的无参数构造方法
public Student(){}
public Student(String name){}
}4.8.什么是方法重载？
在同一个类中方法的名称相同，参数不一样，这种现象就叫方法重载。
注意：方法重载与方法的返回值类型没有关系。
例如：
public class UserBean{
public void test1(){}
public int test1(int num){return 0;}
}
参数不一样---先看个数，后看类型，例如：
public class UserBean{
//参数不一样---先看个数，后看类型
public void test1(int num){}
public int test1(int num1 ,double num2){return 0;} // int double
public int test1(double num2,int num1 ){return 0;} // double int
}4.9.同一个Java类中方法与变量的调用关系？
public class Test5{
public int int1=150;//实例变量
public static String str1="zhangsan";//静态成员变量【类变量】
//同一个类中，方法与变量的关系
//只能用方法调用变量，不能用变量调用方法
//1.构造方法中调用本类变量
//构造方法可以访问实例变量，默认this.实例变量,可以省略this.
//构造方法可以访问类变量，默认类名.类变量,也可以this.类变量，可以省略类名/this.
//构造方法可以访问局部变量，直接使用局部变量名称
/*
public Test5(){
int int2=200;//局部变量
System.out.println("构造方法中调用实例变量默认this.int1=="+this.int1);
System.out.println("构造方法中调用实例变量int1=="+int1);
System.out.println("构造方法中调用类变量默认类名.str1=="+Test5.str1);
System.out.println("构造方法中调用类变量this.str1=="+this.str1);
System.out.println("构造方法中调用类变量str1=="+str1);
System.out.println("构造方法中调用局部变量int2=="+int2);
}
*/
//2.实例方法调用本类变量
//构造方法可以访问实例变量，默认this.实例变量,可以省略this.
//构造方法可以访问类变量，默认类名.类变量,也可以this.类变量，可以省略类名/this.
//构造方法可以访问局部变量，直接使用局部变量名称
/*
public void method(){
int int3=500;//局部变量
System.out.println("实例方法中调用实例变量默认this.int1=="+this.int1);
System.out.println("实例方法中调用实例变量int1=="+int1);
System.out.println("实例方法中调用类变量默认类名.str1=="+Test5.str1);
System.out.println("实例方法中调用类变量this.str1=="+this.str1);
System.out.println("实例方法中调用类变量str1=="+str1);
System.out.println("实例方法中调用局部变量int3=="+int3);
}
*/
//3.静态方法【类方法】调用本类变量
//静态方法中访问类变量默认类名.实例变量,类名可以被省略
//静态方法中不能有this
//静态方法中访问局部变量直接变量名称
public static void staticmethod(){
int int4=850;//局部变量
//错误
//System.out.println("静态方法中调用实例变量默认this.int1=="+this.int1);
//错误
//System.out.println("静态方法中调用实例变量int1=="+int1);
System.out.println("静态方法中调用类变量默认类名.str1=="+Test5.str1);
//错误
// System.out.println("静态方法中调用类变量this.str1=="+this.str1);
System.out.println("静态方法中调用类变量str1=="+str1);
System.out.println("静态方法中调用局部变量int4=="+int4);
}
}测试类：
public class TestMain{
public static void main(String args[]){
//1.构造方法访问变量
//new Test5();
//2.实例方法访问变量
/*
Test5 t5=new Test5();
t5.method();
*/
//3.静态方法访问变量
Test5 t6=new Test5();
t6.staticmethod();
}
}总结，在用一个类中：
1.构造方法中可以访问实例变量/类变量/局部变量
（1）构造方法中访问实例变量默认this.实例变量,this可以被省略。
（2）构造方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
（3）构造方法中访问局部变量直接变量名称
2.实例方法中可以访问实例变量/类变量/局部变量
（1）实例方法中访问实例变量默认this.实例变量,this可以被省略。
（2）实例方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
（3）实例方法中访问局部变量直接变量名称
3.静态方法中可以访问类变量/局部变量，不可以访问实例变量
（1）静态方法中访问类变量默认类名.类变量，类名可以被省略
（2）静态方法中不能有this
（3）静态方法中访问局部变量直接变量名称
4.10.同一个Java类中方法与方法的调用关系？
public class Test6{
//在同一个类中，方法与方法的关系
//1.构造方法 构造方法访问其他方法
//构造方法可以访问其他的构造方法，new 构造方法
//构造方法可以访问实例方法，默认this.实例方法，this.可以省略
//构造方法可以访问类方法，默认类名.类方法，也可以this.类方法，类名.this.可以省略
public Test6(){
new Test6("zhangsan");
this.shiliMethod("lisi");
shiliMethod("lisi");
Test6.staticMethod("wangwu");
this.staticMethod("wangwu");
staticMethod("wangwu");
}
public Test6(String name){
System.out.println("有参数的构造方法，参数name=="+name);
}
//2.实例方法 实例方法访问其他方法
//实例方法可以访问构造方法，new 构造方法
//实例方法可以访问其他实例方法，默认this.实例方法，this.可以省略
//实例方法可以访问类方法，默认类名.类方法，也可以this.类方法，类名.this.可以省略
public void shiliMethod(){
new Test6("zhangsan");
this.shiliMethod("lisi");
shiliMethod("lisi");
Test6.staticMethod("wangwu");
this.staticMethod("wangwu");
staticMethod("wangwu");
}
public void shiliMethod(String name){
System.out.println("有参数的实例方法，参数name=="+name);
}
//3.静态方法 静态方法访问其他方法
//静态方法中绝对不能有this
//静态方法可以访问构造方法，new 构造方法
//静态方法不可以访问实例方法
//静态方法可以访问其他类方法，默认类名.类方法，类名.可以省略
public static void staticMethod(){
new Test6("zhangsan");
//错误
//this.shiliMethod("lisi");
//错误
//shiliMethod("lisi");
Test6.staticMethod("wangwu");
//错误
//this.staticMethod("wangwu");
staticMethod("wangwu");
}
public static void staticMethod(String name){
System.out.println("有参数的静态方法，参数name=="+name);
}
}测试类：
//方法访问其他方法
public class TestMain2{
public static void main(String args[]){
//1.构造方法访问其他方法
// new Test6();
//2.实例方法访问其他方法
Test6 t1=new Test6();
t1.shiliMethod();
//3.静态方法访问其他方法
Test6 t2=new Test6();
t2.staticMethod();
}
}总结，在同一个类中：
1.构造方法中可以访问其他的构造方法/实例方法/类方法
（1）构造方法中访问其他的构造方法new 其他的构造方法;
（2）构造方法中访问实例方法默认this.实例方法,this可以被省略
（3）构造方法中访问类方法默认类名.类方法,也可以this.类方法，类名/this可以省略
2.实例方法中可以访问构造方法/其他实例方法/类方法
（1）实例方法中访问构造方法默认new 构造方法
（2）实例方法中访问其他实例方法默认this.其他实例方法,this可以被省略
（3）实例方法中访问类方法默认类名.类方法,也可以this.类方法，类名/this可以省略
3.静态方法中可以访问构造方法/其他的静态方法，不可以访问实例方法
（1）静态方法中访问构造方法new 构造方法
（2）静态方法中不能有this
（3）静态方法中访问类方法默认类名.类方法,类名可以省略
为什么静态方法中不可以访问实例元素？
静态方法内存分配时机早于实例元素的内存分配时机，静态方法访问实例元素的时候，实例元素是不存在。
“类”的结构图：
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
