java类和方法

  方法，就是一段可以被重复利用的代码的封装 方法定义五要素：修饰词，返回值类型，方法名，  参数列表，方法体。

public static void fun() {
		// public static修饰词 void返回值类型 fun方法名 ()内为参数 {}方法体
	};

优先运行main方法 是程序的入口

没有main方法就没有程序入口，就没有Java appliction

public class Demo01 {

	public static void main(String[] args) {
		// 优先运行main方法 是程序的入口
		// 无参方法的调用
		fun01();
		// 有参数方法的调用，方法需要一个参数的值，需要按照该方法参数的数据类型给其一个真实有效的值
		// 有一种特殊的实参，为引用类型
		// 实参的数据类型必须与形参的数据类型一直或者是形参的子类型
		fun02("橘子");
		// 按照参数位置进行传值
		fun03(1,"西瓜");
		//代码将两个整数相加 将相加结果返回 关键字return,将方法执行结果返回 方法的返回值类型与return后的数据类型有关
		long num = fun04(10, 15);
		System.out.println(num);
	}

	public static void fun() {
		// public static修饰词 void返回值类型 fun方法名 ()内为参数 {}方法体
	};

	
	public static void fun01() {
		System.out.println("北风卷地白草折");
	};

	
	public static void fun02(String food) {
		System.out.println("吃" + food);
	}

	
	public static void fun03(int count, String food) {
		System.out.println("吃了" + count + "个" + food);
	};

	public static long fun04(int a, int b) {
		
		return a + b;
	};
}

在同一个类中方法参数列表不同的同名方法这种表现形式我们成为方法重载

参数列表：参数的数量 参数的数据类型

数据类型不同指的是同一参数位置的参数数据类型不同

public class Demo02 {
	public static void eat() {
		System.out.println("吃");
	}
	//与上一个方法名相同，但是参数数量不同
	public static void eat(String food) {
		System.out.println("吃" + food);
	}
	//与上一个方法名相同，但是参数数量不同
	public static void eat(int count,String food) {
		System.out.println("吃" +count + "个" + food);
	}
	//与上一个方法名相同，参数数量也相同，但是参数数据类型不同
	public static void eat(String food,int count) {
		System.out.println("吃" +count + "个" + food);
	}
}

一个方法中无法读取另一个方法中声明的变量

声明在方法中的变量称为局部变量，仅在局部有效

声明在类中的变量称之为成员变量

当读取的变量在局部代码中没有被声明,则去找成员变量

当读取的变量在局部代码中已经被声明之后，则根据就近原则读取局部变量，不需要去找成员变量

Static修饰的成员变量（静态成员变量）是可以被该类的所有方法共享的

static修饰变量时只能修饰成员变量不能修饰局部变量

static修饰的方法称之为静态方法，静态方法只能访问静态成员变量

static修饰的方法称之为静态方法，反之称之为非静态方法或普通方法，也就是平时说的方法一般指的是非静态方法

public class Demo03 {
	static int a = 30;
	int b = 40;
	public static void main(String[] args) {
		//fun01();
		//fun02();
		//fun03();
		//fun04();
		fun05();
		fun06();
	}
	public static void fun01() {
		int x = 10;
		int y = 20;
		System.out.println("方法fun01 变量 x >>>" + x);
		System.out.println("方法fun01 变量 y >>>" + y);
	}
	public static void fun02() {
		int x= 20;
		System.out.println("方法fun01 变量 x >>>" + x);
		//一个方法中无法读取另一个方法中声明的变量
		//System.out.println("读取方法fun01 变量 y >>>" + y);
	}
	public static void fun03() {
		//当读取的变量在局部代码中没有被声明,则去找成员变量
		System.out.println(a);
	}
	public static void fun04() {
		//当读取的变量在局部代码中已经被声明之后，则根据就近原则读取局部变量，不需要去找成员变量
		int a =20;
		System.out.println(a);
	}
	public static void fun05() {
		a += 10;
		System.out.println("fun05执行后a=" + a);
	}
	public static void fun06() {
		a += 20;
		System.out.println("fun06执行后a=" + a);
	}
	public static void fun07() {
		System.out.println("静态成员变量a=" + a);
		//静态方法之只能访问静态成员变量
		//System.out.println("非静态成员变量b=" + b);
	}
	public void fun08() {
		//非静态方法既能访问静态成员变量也能访问非静态成员变量
		System.out.println("静态成员变量a=" + a);
		System.out.println("非静态成员变量b=" + b);
	}
}