Java程序中函数的理解及应用

/**
 * 
 * @author zhaocx1
 *
 */
/*
 * public static void main(String[] args)	
 * 主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用。
 * 
 * 主函数的定义：
 * public：代表着该函数访问权限是最大的。
 * static：代表着主函数随着类的加载就已经存在了。
 * void：主函数没有具体的返回值。
 * main:不是关键字，但是是一个特殊单词，可以被jvm识别
 * 函数的参数：(String[] arr):主函数的参数。参数类型是一个数组，该数组中的元素是一个字符串。字符串类型的数组。
 * 
 * 主函数是固定格式的：jvm识别。
 * 
 * jvm在调用主函数是，传入的是new String[0];
 * 
 */                                                                         


public class MainDemo {
	public static void main(String[] args)//主函数	
	{
		System.out.println("hello world");//输出打印
	}
}

/**
 * @author zhaocx1 
 * 什么时候构造函数呢？ 当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
 * 
 * 构造代码块。 作用：给对象进行初始化。 对象一建立就运行，而且优先于构造函数。 
 * 和构造函数的区别：构造代码块是给所有对象进行统一初始化。
 * 而构造函数是给对应的对象进行初始化。 构造代码块中定义的是不同对象共性的初始化内容。
 */
/*
 * 对象一建立就会调用与之对应的构造函数。
 * 构造函数的作用，可以用于给对象进行初始化。
 * 构造函数的小细节：
 * 当一个类中没有定义构造函数时，那么系统会默认给给该类加入一个空参数的构造函数。
 * 当在类中自定义了构造函数后，默认的构造函数就没有了。
 */
public class Person1 {
	public static void main(String[] args) {//主函数，整个程序运行的切入点
		System.out.println("hello world");//输出打印
	}

}

//需求：描述汽车（颜色，轮胎数）。描述事物其实就是描述事物的属性和行为。
//属性对应是类中变量，行为对应的类中的函数(方法).
//其实定义类，就是在描述事物，就是在定义属性和行为。 属性和行为共同成为类中的成员(成员变量和成员方法).
class Car {
	// 描述颜色
	String color = "红色";
	// 描述轮胎数
	int num = 4;

	// 运行行为。
	void run() {
		System.out.println(color + "" + num);
	}
}

public class CarDemo {
	public static void main(String[] args) {
		// 生产汽车。在Java中通过new操作符来完成。
		// 其实就是在堆内存中产生一个实体。
		Car c = new Car();// c就是一个类类型变量。记住类类型变量指向对象。
		// 需求：将已有车的颜色改成蓝色，指挥该对象做使用，在Java中指挥方式：对象.对象成员
		c.color = "blue";
		c.run();
		Car c1 = new Car(); // 多个引用 指向同一个变量
		c1 = new Car();

		// 成员变量和局部变量。
		// 作用范围：成员变量作用于整个类中。
		// 局部变量作用于函数中，或者语句中
		// 在内存中的位置：
		// 成员变量：在堆内存中，因为对象的存在，才在内存中存在。
		// 局部变量：存在栈内存中。

	}

}

 */
/*
 * static关键字的含义及用法：
 * 
 * 静态：static。
 * 用法：是一个修饰符，用于修饰成员(成员变量，成员函数).只能修饰成员，不能修饰对象。
 * 静态修饰符被对象所共享。
 * 当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名，静态成员。
 * 方法区，共享区，数据区
 * 
 * static特点：
 * 1.随着类的加载而加载，
 * 	 也就是说，静态随着类的消失而消失，说明它的生命周期最长。
 * 2.优先于对象存在，
 * 	 明确一点：静态是先存在。对象是后存在的。
 * 3.被所有对象所共享，
 * 4.可以直接被类名调用。
 * 
 * 实例变量和类变量的区别：
 * 1.存放位置。
 * 	类变量随着类的加载而存在于方法区中。
 *  实例变量随着对象的建立而存在于堆内存中。
 * 2.生命周期：
 * 	类变量生命周期最长，随着类的消失而消失。
 * 	实例变量生命周期对着对象的消失而消失。
 * 
 * 静态使用注意事项：
 * 1.静态方法只能访问静态成员。
 * 	非静态方法既可以访问静态也可以访问非静态。
 * 2.静态方法中不可以定义this，super关键字。
 * 	因为静态优先于对象存在。所以静态方法中不可以出现this。
 * 3.主函数是静态的。
 * 
 * 静态有利有弊
 * 利处：对对象的共享数据惊醒单独空间的存储，节省空间。没有必要每个对象都存储 一份。
 * 		可以直接被类名调用。
 * 弊端：生命周期过长。访问出现局限性。（静态虽好，只能访问静态）
 */

class Person {//定义一个类
	String name;// 成员变量，实例变量。
	static String country = "CN";// 静态的成员变量，类变量。

	public static void show() {//静态函数，只能访问静态变量
		System.out.println("::" + country);
	}
}

class StaticDemo {
	public static void main(String[] args) {//主函数，整个程序的切入点
		// Person p=new Person();//对象进行初始化
		// p.name="zhangsan";//对象进行赋值
		// p.show();//调用类中方法
		// System.out.println(p.country);
		// System.out.println(Person.country);//对象调用静态变量
		Person.show();//调用静态函数

	}
}

/**
 * 
 * @author zhaocx1
 *
 */

/*
 * 静态代码块：
 * 格式：
 * static
 * {
 * 		静态代码块中的执行语句。
 * }
 * 
 * 特点：随着类的加载而执行，只执行一次，优先于主函数执行。
 *     用于给类进行初始化的。 
 * 
 */
class StaticCode {//定义一个类
	int num = 9;//初始化一个int类型的变量
    {
		System.out.println("f");//输出语句
	}

	static {//定义静态代码块，里面的内容先于主函数执行，并且执行一次
		System.out.println("aa");
	}

	StaticCode(int x) {//定义一个函数，并传递一个int类型的参数
		System.out.println("d");
	}

	public static void show() {//定义一个方法，该方法只有被调用时才执行
		System.out.println("show run");
	}

}

public class StaticCodeDemo {
	static {//定义静态代码块，里面的内容先于主函数执行，并且执行一次
		System.out.println("b");
	}

	public static void main(String[] args) {//主函数，整个函数的切入点
		new StaticCode(4);//传递一个数据并调用类中的方法
		// new StaticCode();
		// new StaticCode();
		// System.out.println("over");
		// StaticCode.show();
		// StaticCode s=null;
		// s=new StaticCode();

		// StaticCode.show();
	}

	static {//定义静态代码块，里面的内容先于主函数执行，并且执行一次
		System.out.println("c");
	}

}