类和对象_2
1.Java类中方法的表现形式及其基本特征?
Java类中方法是为了描述具有共同性质的一组数物的基本功能/行为。
1.1.Java类中方法的表现形式
1.实例方法格式
访问限制修饰符 方法的返回值数据类型 方法的名称(参数列表){方法体}
1)访问限制修饰符---public 缺省的
2)方法的返回值数据类型
返回值-----方法执行结果
数据类型---基本数据类型【复合数据类型】
有返回值---方法体中的最后一句话是“return”,方法的返回值数据类型一定是结果值的具体数据类型
没有返回值---方法体中的没有“return”,方法的返回值数据类型void代替。
3)方法的名称---合法的标识符【首字母小写,从第二个单词开始首字母大写】
4)参数列表
参数----引入本方法以外的数据进入本方法进行运算【找帮手】局部变量
列表----可以有多个
没有参数的时候--()中的内容是空的
5)方法体--方法的身体【具体执行代码】
例如:
public class Tect1{
//1.实例方法
//1.没有返回值,没有参数的实例方法
public void method1(){
}
//2.有返回值【int】,没有参数的实例方法
public int method2(){
return 0;//返回的时最后的结果
}
//3.没有返回值,有一个int参数的实例方法
public void method3(int num){
}
//4.有返回值片【String】,有一个int参数的方法,一个String参数的实例方法
public String method4(int num1,String str){
return "hello";
}
}
2.静态方法格式
实例方法的访问限制修饰符后面加上static关键字的方法就是静态方法【类方法】
没有static关键字的方法就是实例方法
例如:
public class Tect2{
//2.静态方法
//1.没有返回值,没有参数的静态方法
public static void method1(){
}
//2.有返回值【int】,没有参数的静态方法
public static int method2(){
return 0;
}
//3.没有返回值,有一个参数int的静态方法
public static void method3(int num){
}
//4.有返回值[String],有一个int参数,有一个String参数的静态方法
public static String method4(int num,String str){
return "Hello";
}
}
3.构造方法格式
实例方法格式中去掉方法的返回值数据类型,方法的名称是类名这种方法就叫构造方法。
例如:
public class Tect3{
//3.构造方法
//1.没有参数的构造方法【无参构造方法】
public Tect3(){
}
//2.有一个int参数的构造方法
public Tect3(int num){
}
//3.有多个参数的构造方法
public Tect3(int num,String str){
}
}
构造方法作用就是将来为了创建对象用的。
当一个类创建好以后,会有一个默认的无参数构造方法存在,只是没有显式写出罢了。
当这个类中出现一个有参数的构造方法时,我们就需要将这个默认的无参数构造方法显式写出,如果没有
显式写出这个默认的无参数构造方法,那么这个默认的无参数构造方法将会被有参数的构造方法覆盖。
public class Student{
//存在一个默认的无参数构造方法
//当有参数的构造方法时,无参构造方法要写出来,否则会被覆盖
public Student(){}
public Student(String name){}
}
2.什么是方法重载?
在同一个类中方法的名称相同,参数不一样,这种现象就叫方法重载。
注意:方法重载与方法的返回值类型没有关系
例如:
public class Tect4{
//方法重载
//在同一个类中,方法的名称相同,参数不同就是方法重载
//注意:方法重载与方法的返回值类型没有关系
//同一个类中,方法的名称相同,参数不同
//参数不同:1.个数不同 2.数据类型不同
//1.实例方法重载
public void shiliMethod(){}
public void shiliMethod(int num){}
public void shiliMethod(String str){}
//与返回值的数据类型无关,所以当参数的数据类型相同时,就会报错
// public String shiliMethod(String str){}
public String shiliMethod(String str,String str2){
return "hello";
}
//2.静态方法重载
public static void staticMethod(){}
public static void staticMethod(int num){}
public static void staticMethod(String str){}
public static String staticMethod(String str,String str2){
return "hello";
}
//3.构造方法重载
public Tect4(){}
public Tect4(int num){}
public Tect4(String str){}
public Tect4(String str,String str2){}
}
3.同一个Java类中方法与变量的调用关系?
1.在同一个类中,构造方法中可以访问实例变量/类变量/局部变量
1)构造方法中访问实例变量默认this.实例变量,this可以被省略。
2)构造方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
3)构造方法中访问局部变量直接变量名称
2.在同一个类中,实例方法中可以访问实例变量/类变量/局部变量
1)实例方法中访问实例变量默认this.实例变量,this可以被省略。
2)实例方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
3)实例方法中访问局部变量直接变量名称
3.在同一个类中,静态方法中可以访问类变量/局部变量,不可以访问实例变量
1)静态方法中访问类变量默认类名.实例变量,类名可以被省略
2)静态方法中不能有this
3)静态方法中访问局部变量直接变量名称
例如:
//方法调变量
public class Tect5{
public int tesid=1001;//实例变量
public static String testname="张三";//静态成员变量【类变量】
//同一个类中方法与变量的关系
//1.只能在方法中调用变量变量,不能用变量调用方法
//1.构造方法中调用本类变量
//构造方法中可以访问实例变量,默认this.实例变量,也可以省略this.
//构造方法中可以类变量,默认类名.类变量,也可以this.类变量,可以省略类名.,this.
//构造方法中可以访问局部变量,直接局部变量的名称
public Tect5(){
char val='G';
System.out.println("构造方法中调用实例变量默认this.tesid=="+this.tesid);
System.out.println("构造方法中调用实例变量tesid=="+tesid);
System.out.println("构造方法中调用静态变量默认类名Tect5.testname=="+Tect5.testname);
System.out.println("构造方法中调用静态变量this.testname=="+this.testname);
System.out.println("构造方法中调用静态变量testname=="+testname);
System.out.println("构造方法中调用局部变量val=="+val);
}
//2.实例方法中调用本类变量
//实例方法中可以访问实例变量,默认this.实例变量,也可以省略this.
//实例方法中可以类变量,默认类名.类变量,也可以this.类变量,可以省略类名.,this.
//实例方法中可以访问局部变量,直接局部变量的名称
public void shiliMethod(){
char val='G';
System.out.println("实例方法中调用实例变量默认this.tesid=="+this.tesid);
System.out.println("实例方法中调用实例变量tesid=="+tesid);
System.out.println("实例方法中调用静态变量默认类名Tect5.testname=="+Tect5.testname);
System.out.println("实例方法中调用静态变量this.testname=="+this.testname);
System.out.println("实例方法中调用静态变量testname=="+testname);
System.out.println("实例方法中调用局部变量val=="+val);
System.out.println("================================");
}
//3.静态方法中调用本类变量
//静态方法中绝对不能用this
//静态方法中不能访问实例变量
//静态方法中可以访问类变量,默认类名.类变量,可以省略类名.
//静态方法中可以本方法的局部变量,直接使用局部变量名称
public static void staticMethod(){
char val='G';
//静态方法中不能调用实例变量
//System.out.println("静态方法中调用实例变量默认this.testid=="+this.testid);
//静态方法中不能调用实例变量
//System.out.println("静态方法中调用实例变量testid=="+testid);
System.out.println("静态方法中调用静态变量默认类名Tect5.testname=="+Tect5.testname);
//无法从静态上下文中引用非静态 变量 this
//System.out.println("静态方法中调用静态变量this.testname=="+this.testname);
System.out.println("静态方法中调用类变量testname=="+testname);
System.out.println("静态方法中调用局部变量val=="+val);
}
}
测试类:
public class TectMain{
public static void main(String args[]){
//测试构造方法
Tect5 t5=new Tect5();
//测试实例方法
t5.shiliMethod();
//测试静态方法
t5.staticMethod();
}
}
4.同一个Java类中方法与方法的调用关系?
1.在同一个类中,构造方法中可以访问其他的构造方法/实例方法/类方法
1)构造方法中访问其他的构造方法new 其他的构造方法;
2)构造方法中访问实例方法默认this.实例方法,this可以被省略
3)构造方法中访问类方法默认类名.类方法,也可以this.类方法,类名/this可以省略
2.在同一个类中,实例方法中可以访问构造方法/其他实例方法/类方法
1)实例方法中访问构造方法默认new 构造方法
2)实例方法中访问其他实例方法默认this.其他实例方法,this可以被省略
3)实例方法中访问类方法默认类名.类方法,也可以this.类方法,类名/this可以省略
3.在同一个类中,静态方法中可以访问构造方法/其他的静态方法,不可以访问实例方法
1)静态方法中访问构造方法new 构造方法
2)静态方法中不能有this
3)静态方法中访问类方法默认类名.类方法,类名可以省略
例如:
public class Tect6{
//同一个类中,方法与方法的关系
//1.构造方法访问其他的方法,
//构造方法可以访问其他的构造方法,new 构造方法名称
//构造方法可以访问实例方法,默认this.实例方法名称,this可以省略
//构造方法可以访问类方法,默认类名.类方法名称,也可以this.类方法名称,类名.this.可以省略
public Tect6(){
System.out.println("构造方法访问其他方法");
new Tect6("zhangsan");
this.shiliMethod("西安");
shiliMethod("西安");
Tect6.staticMethod("大明");
this.staticMethod("大明");
staticMethod("大明");
System.out.println("======================================");
}
public Tect6(String name){
System.out.println("有参数的构造方法,参数name=="+name);
}
//2.实例方法访问其他的方法
//实例方法可以访问构造方法,new 构造方法名称
//实例方法可以访问其他实例方法,默认this.实例方法名称,this可以省略
//实例方法可以访问静态方法,默认类名.类方法名称,也可以this.类方法名称,类名.this.可以省略
public void shiliMethod(){
System.out.println("实例方法访问其他方法");
new Tect6("李四");
this.shiliMethod("北京");
shiliMethod("北京");
Tect6.staticMethod("大汉");
this.staticMethod("大汉");
staticMethod("大汉");
System.out.println("======================================");
}
public void shiliMethod(String address){
System.out.println("有参数的实例方法,参数address=="+address);
}
//3.静态方法
//静态方法中绝对不能有this
//静态方法可以访问构造方法,new 构造方法
//静态方法不可以访问实例方法
//静态方法可以访问其他类方法,默认类名.类方法,类名.可以省略
public static void staticMethod(){
System.out.println("静态方法访问其他方法");
new Tect6("zhaosi");
//错误: 无法从静态上下文中引用非静态 方法 shiliMethod(String)
//this.shiliMethod("南京");
//错误: 无法从静态上下文中引用非静态 方法 shiliMethod(String)
//shiliMethod("南京");
Tect6.staticMethod("大秦");
//无法从静态上下文中引用非静态 变量 this
//this.staticMethod("大秦");
staticMethod("大秦");
}
public static void staticMethod(String val){
System.out.println("有参数的静态方法,参数val=="+val);
}
}
测试类:
public class TectMain1{
public static void main(String args[]){
//测试构造方法
Tect6 t6=new Tect6();
//测试实例方法
t6.shiliMethod();
//测试静态方法
t6.staticMethod();
}
}
5.为什么静态方法中不可以访问实例元素?
静态方法内存分配时机早于实例元素的内存分配时机,静态方法访问实例元素的时候,实例元素是不存在。
6.为什么静态方法可以可以访问构造方法,不能访问实例元素?
构造方法是特殊的方法,是类初始化的入口,构造方法不需要实例化对象就能使用
jvm中有类加载器,第一次加载类时构造方法也会随着类一起加载分配内存空间,jvm中的类加载器第一次加载类时会执行类中
的static域,jvm会专门划分一个内存区域给static程序块,可称为静态区,属于static这个类;而this指针指向的是类的对象,在实例
化对象(new)时jvm会在堆区分配内存给一个具体对象,this指针指向的是这个对象,而类中的static域始终是在静态区分配内存 this
指向了堆区所以不能调用。所以静态方法可以访问构造方法,并且不能使用this。
7.类的结构