java中的变量、方法

​
​

活动地址：CSDN21天学习挑战赛

4.1.类是什么？
1.类–类型–数据类型—复合数据类型—自定义复合数据类型
为什么有复合数据类型？
基本数据类型就8种，在开发中远远不够，所以我们就需要一个可以根据自己的需求随时能制作出一个自己需要的数据类型。
2.类–具有共同性质的一组事物的群体。 人类

在java中用来描述具有共同性质的一组事物的自定义的复合数据类型—类。
复合数据类型的本质—【根据自己的需求制作自己需要的数据类型的模式/规则/公式】

4.2.如何编写一个Java类？
通过class关键字来创建一个类
例如:
public class Hello{

}
public—访问限制修饰符【对类的访问权限】
class—创建类的关键字【类的标志】
Hello–类名【首字母大写】
{}----类体
格式:
访问限制修饰符 class 类名{}
例如：
public class Student{ }
class User{ }
4.3.Java类中可以编写什么？
描述一组事物的共同性质
杯子–名字
形状
大小
颜色
装东西
名字，形状，大小，颜色-----基本属性
装东西—基本功能
通过事物的基本属性和基本功能来描述具有共同性质的一组事物。
基本属性------变量
基本功能-----方法
变量–是用来在类中描述事物的基本属性
方法–是用来在类中描述事物的基本功能
4.4.Java类中变量的分类及其基本特征？
变量—保存数据
1.数据类型【不一定就是之前的基本数据类型，也有可能是自定义的复合数据类型】
2.变量名称【合法标识符–全字母小写】
3.初始值
4.作用域
按照在类中编写变量的位置划分：
1.成员变量【全局变量】—类中方法外
1.可以使用访问限制修饰符,也可以不使用。
2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
3.可以在本类中的任意一个方法中被使用

2.局部变量-----------------------方法里/方法参数
1.不能使用访问限制修饰符。
2.必须设置初始值
3.只能在本方法中使用。
例如:
public class Student{
public int stuid1; //可以使用访问限制修饰符
int stuid2; //也可以不使用限制修饰符[缺省的访问限制修饰符]
public String stuname1; //可以不用赋予初始值，系统自动赋予默认值
public String stuname2=“zhangsan”;//也可以根据需要自己设置一个初始值。

//成员变量【全局变量】---可以在本类中的任意一个方法中被使用
public  void  testMethod1(){
 		System.out.println("stuid1=="+stuid1);
	System.out.println("stuname2=="+stuname2);
}

public  void  testMethod2(){
 		System.out.println("stuid1=="+stuid1);
	System.out.println("stuname2=="+stuname2);
}
//......
public  void  testMethod_n(){
 		System.out.println("stuid1=="+stuid1);
	System.out.println("stuname2=="+stuname2);
}

}
public class Person{
//方法1–testMethod1
public void testMethod1(){

 //public  char  sex; //不能使用访问限制修饰符。

//char sex; //必须设置初始值
char sex=’男’; //局部变量
//只能在本方法中使用
System.out.println(“sex==”+sex);
}

	//方法2--testMethod2

public void testMethod2(){
//只能在本方法中使用,超出本方法就不能使用
//System.out.println(“sex==”+sex);
}
}

4.5.什么是成员变量的隐藏？
在同一个类中成员变量与某一个方法中的局部变量的名称相同，这是我们在方法中使用这个成员变量的时候，得到的结果是局部变量的值，此时就是方法中的局部变量将类中成员变量的值隐藏了，这就是成员变量的隐藏。
例如：
public class User{
//成员变量
public String username=”zhangsan”;

public void testMethod1(){
//局部变量
char username=’A’;
//成员变量的隐藏
//成员变量的隐藏与变量数据类型无关，只与变量名称有关。
System.out.println(“username==”+username); //usernameA
//如果我们需要强制使用被隐藏的成员变量，该怎么办？
//通过this访问被隐藏的成员变量
System.out.println(“username”+this.username); //username==zhangsan
}
}

4.6.静态成员变量与实例变量的区别？
静态成员变量与实例变量----都是成员变量【全局变量】
1.可以使用访问限制修饰符,也可以不使用。
2.可以不用赋予初始值，系统自动赋予默认值，也可以根据需要自己设置一个初始值。
3.可以在本类中的任意一个方法中被使用
成员变量【全局变量】可以分为2种
按照成员变量【全局变量】是否使用static关键字
静态成员变量【类变量】—使用static关键字修饰的成员变量【全局变量】
实例变量—没有使用static关键字修饰的成员变量【全局变量】
static关键字—静态的—》提前分配存储数据的内存空间
没有使用static关键字修饰的元素，是在程序运行时分配存储数据的内存空间。
使用static关键字修饰的元素，是在程序运行前分配存储数据的内存空间。
例如：
public class TestClass{
public int classid=1001; //实例变量
public static String classname=”java班”; //静态成员变量【类变量】
static String classcode=”20200728”;//静态成员变量【类变量】
}

1.Java类中方法的表现形式及其基本特征？
Java类中方法是为了描述具有共同性质的一组数物的基本功能/行为。
Java类中方法的表现形式
1.实例方法格式
访问限制修饰符 方法的返回值数据类型 方法的名称（参数列表）{方法体}
1.访问限制修饰符—public 缺省的
2.方法的返回值数据类型
返回值-----方法执行结果
数据类型—基本数据类型【复合数据类型】
有返回值—方法体中的最后一句话是“return”,方法的返回值数据类型一定是结果值的具体数据类型
没有返回值—方法体中的没有“return”,方法的返回值数据类型void代替。
3.方法的名称—合法的标识符【首字母小写，从第二个单词开始首字母大写】
4.参数列表
参数----引入本方法以外的数据进入本方法进行运算【找帮手】局部变量
列表----可以有多个
没有参数的时候–（）中的内容是空的
5.方法体–方法的身体【具体执行代码】
例如：
public void test1(){ } — 没有返回值，没有参数的实例方法
public int test2(){ return 12;}—返回值为int,没有参数的实例方法
public void test3(int a){ } ---- 没有返回值,有参数1个int型参数的实例方法
public String test4(UserBean user){ return “hello”;}—返回值为String的，有一个UserBean参数的实例方法。
public Student test5(UserBean user,int num,char value){ return null;}

2.静态方法格式
实例方法的访问限制修饰符后面加上static关键字的方法就是静态方法【类方法】
没有static关键字的方法就是实例方法
例如：
public static void test1(){ } — 没有返回值，没有参数的静态方法【类方法】
public static int test2(){ return 12;}—返回值为int,没有参数的静态方法【类方法】
public static void test3(int a){ } ---- 没有返回值,有参数1个int型参数的静态方法【类方法】
public static String test4(UserBean user){ return “hello”;}—返回值为String的，有一个UserBean参数的静态方法【类方法】。
public static Student test5(UserBean user,int num,char value){ return null;}

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 Person{
public int perid=1001;//实例变量
public static String pername=“zhangsan”;//类变量
//构造方法中可以访问实例变量/类变量/局部变量
public Person(){
char sex=‘男’; //局部变量
//构造方法中访问实例变量默认this.实例变量,this可以被省略。
System.out.println(“构造方法中-实例变量-perid【默认】"+this.perid);
System.out.println("构造方法中-实例变量-perid”+perid);
//构造方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
System.out.println(“构造方法中-类变量-pername【类名】"+Person.pername);
System.out.println("构造方法中-类变量-pername【this】”+this.pername);
System.out.println(“构造方法中-类变量-pername==”+pername);
//构造方法中访问局部变量直接变量名称
System.out.println(“构造方法中-局部变量-sex==”+sex);
}

    //实例方法中可以访问实例变量/类变量/局部变量
public  void  testMehtod1(){
	char  sex='男'; //局部变量
	//实例方法中访问实例变量默认this.实例变量,this可以被省略。
	System.out.println("实例方法中-实例变量-perid【默认】=="+this.perid);
	System.out.println("实例方法中-实例变量-perid=="+perid);
	//实例方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
	System.out.println("实例方法中-类变量-pername【类名】=="+Person.pername);
	System.out.println("实例方法中-类变量-pername【this】=="+this.pername);
	System.out.println("实例方法中-类变量-pername=="+pername);
	//实例方法中访问局部变量直接变量名称
	System.out.println("实例方法中-局部变量-sex=="+sex);
}

//静态方法中不可以访问实例变量变量
//静态方法中可以访问类变量/局部变量

public static  void  testStaticMehtod(){
	char  sex='男'; //局部变量
	//System.out.println("静态方法中-实例变量-perid=="+perid);//错误
	//静态方法中访问类变量默认类名.实例变量,类名可以被省略
	System.out.println("实例方法中-类变量-pername【类名】=="+Person.pername);
	//静态方法中不能有this
	//System.out.println("实例方法中-类变量-pername【this=="+this.pername);
	System.out.println("静态方法中-类变量-pername=="+pername);
	//静态方法中访问局部变量直接变量名称
	System.out.println("静态方法中-局部变量-sex=="+sex);
}

}

public class TestMain{
public static void main(String args[]){
Person per1=new Person();
per1.testMehtod1();
per1.testStaticMehtod();
}
}

总结:
在用一个类中：
构造方法中可以访问实例变量/类变量/局部变量
//构造方法中访问实例变量默认this.实例变量,this可以被省略。
//构造方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
//构造方法中访问局部变量直接变量名称

实例方法中可以访问实例变量/类变量/局部变量
//实例方法中访问实例变量默认this.实例变量,this可以被省略。
//实例方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
//实例方法中访问局部变量直接变量名称

静态方法中可以访问类变量/局部变量，不可以访问实例变量
//静态方法中访问类变量默认类名.实例变量,类名可以被省略
//静态方法中不能有this
//静态方法中访问局部变量直接变量名称

为什么静态方法中不可以访问实例变量变量？
静态方法内存分配时机早于实例变量的内存分配时机，静态方法访问实例变量的时候，实例变量是不存在。

4.10.同一个Java类中方法与方法的调用关系？
在用一个类中：
构造方法中可以访问其他的构造方法/实例方法/类方法
//构造方法中访问其他的构造方法new 其他的构造方法;
//构造方法中访问实例方法默认this.实例方法,this可以被省略
//构造方法中访问类方法默认类名.类方法,也可以this.类方法，类名/this可以省略

实例方法中可以访问构造方法/其他实例方法/类方法
//实例方法中访问构造方法默认new 构造方法
//实例方法中访问其他实例方法默认this.其他实例方法,this可以被省略
//实例方法中访问类方法默认类名.类方法,也可以this.类方法，类名/this可以省略

静态方法中可以访问构造方法/其他的静态方法，不可以访问实例方法
//静态方法中访问构造方法new 构造方法
//静态方法中不能有this
//静态方法中访问类方法默认类名.类方法,类名可以省略
代码示例：

public class  Person{
       public  int  perid=1001;//实例变量
       public static  String pername="zhangsan";//类变量
       //构造方法中可以访问实例变量/类变量/局部变量
       public  Person(){
		char  sex='男'; //局部变量
		//构造方法中访问实例变量默认this.实例变量,this可以被省略。
		System.out.println("构造方法中-实例变量-perid【默认】=="+this.perid);
		System.out.println("构造方法中-实例变量-perid=="+perid);
		//构造方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
		System.out.println("构造方法中-类变量-pername【类名】=="+Person.pername);
		System.out.println("构造方法中-类变量-pername【this】=="+this.pername);
		System.out.println("构造方法中-类变量-pername=="+pername);
		//构造方法中访问局部变量直接变量名称
		System.out.println("构造方法中-局部变量-sex=="+sex);
	}
	
        //实例方法中可以访问实例变量/类变量/局部变量
	public  void  testMehtod1(){
		char  sex='男'; //局部变量
		//实例方法中访问实例变量默认this.实例变量,this可以被省略。
		System.out.println("实例方法中-实例变量-perid【默认】=="+this.perid);
		System.out.println("实例方法中-实例变量-perid=="+perid);
		//实例方法中访问类变量默认类名.实例变量,也可以this.类变量,类名/this可以被省略
		System.out.println("实例方法中-类变量-pername【类名】=="+Person.pername);
		System.out.println("实例方法中-类变量-pername【this】=="+this.pername);
		System.out.println("实例方法中-类变量-pername=="+pername);
		//实例方法中访问局部变量直接变量名称
		System.out.println("实例方法中-局部变量-sex=="+sex);
	}
	
	//静态方法中不可以访问实例变量变量
	//静态方法中可以访问类变量/局部变量
	
	public static  void  testStaticMehtod(){
		char  sex='男'; //局部变量
		//System.out.println("静态方法中-实例变量-perid=="+perid);//错误
		//静态方法中访问类变量默认类名.实例变量,类名可以被省略
		System.out.println("实例方法中-类变量-pername【类名】=="+Person.pername);
		//静态方法中不能有this
		//System.out.println("实例方法中-类变量-pername【this=="+this.pername);
		System.out.println("静态方法中-类变量-pername=="+pername);
		//静态方法中访问局部变量直接变量名称
		System.out.println("静态方法中-局部变量-sex=="+sex);
	}
	


}

public class  Student{
      public  Student(){
	new Student(1);
	this.shiLiMethod1();
	shiLiMethod1();
        Student.leiMethod1();
	this.leiMethod1();
        leiMethod1();
      }
	
      public  Student(int num){
		System.out.println("构造方法");
      }

      public  void shiLiMethod1(){
		System.out.println("实例方法");
      }		
      public static void leiMethod1(){
		System.out.println("类方法");
      }
}

public  class  TestMain{
	public static void main(String args[]){
	   Person per1=new Person();
	   per1.testMehtod1();
           per1.testStaticMehtod();
	}
}

public  class  TestStudent{
	public static void main(String args[]){
	   Student stu1=new Student();
	   
	}
}