Java构造方法与static关键字的学习

 构造方法：给对象的数据属性进行初始化
         构造方法与类名相同，没有返回值类型，连void都没有，没有具体的返回值return;
构造方法的重载：方法名相同，与返回值类型无关，只看参数列表
         如果没由给出构造方法，则系统将自动提供一个无参构造方法
         如果给出了构造方法，系统将不再提供默认的无参构造方法
         构造方法不能用对象调用，在一创建对象的时候，系统直接调用了构造方法
给成员变量赋值的两种方式
     1.setXxx()方式
         修改属性值
     2.构造方法
         给对象中数据属性进行初始化
static关键字的特点：
        随着类的加载而加载
        静态优先于对象存在
        被类的所以对象共享；如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的
        可以通过类名调用
        共性用静态，特性用非静态
static使用的注意事项：
        静态方法只能访问静态的成员变量和静态的成员方法
            静态方法：成员变量只能访问静态变量，成员方法只能访问静态成员方法
            非静态方法：成员变量可以是静态的，也可以是非静态的，成员方法可以是静态的成员方法，也可以是非静态的成员方法
静态变量和成员变量的区别
        静态变量属于类，所以也叫类变量
        成员变量属于对象，所以也叫对象变量
        静态变量存储与方法区的静态区，成员变量存储于堆内存
        静态变量随着类的加载而加载，随着类的消失而消失
        成员变量随着对象的创建而存在，随着对象的消失而消失
        静态变量可以通过类名调用，也可以通过对象调用
        成员变量只能通过对象名调用 

 

学习的测试代码如下

package pra_01;
public class j_07 {
	public static void main(String[] args){
		System.out.println("构造方法");
		Person p2=new Person();	
		p2.showp();
		Person2 p3=new Person2();	//找的是空参构造
		
		Person2 p4=new Person2("bb",22);
		p4.show();
		
		Person3 p5=new Person3("cc",33);
		//p5=new Person("zz",99);	这种方式不是修改属性值，而是将原对象成为垃圾，不建议
		System.out.println(p5.getName()+"..."+p5.getAge());
		
		Person3 p6=new Person3();
		p6.setName("dd");
		p6.setAge(44);
		//p6.setName("zz");			这种方式才是修改属性值
		System.out.println(p6.getName()+"..."+p6.getAge());
		
		Student stu=new Student();		//使用的是无参构造
		stu.setName("ee");
		stu.setAge(55);
		System.out.println(stu.getName()+"..."+stu.getAge()+"...");
		
		Student stu2=new Student("ff",66);		//使用的是有参构造
		stu2.show();
		
		//static关键字的演示
		Static_e s1=new Static_e();
		s1.name="sta2";
		s1.age=18;
		s1.show();
		
		Static_e s2=new Static_e();				//由于age定义时加了static关键字，所以s2的age属性值不用赋值就可以调用上一个对象的age值
		s2.name="sta3";
		s2.show();
		
		//static注意事项的演示
		Notice no=new Notice();
		no.show1();
	}
}
class Person{
	private String name;
	private int age;
	
	//定义一个构造方法
	public Person(){
		System.out.println("构造方法1");
		name="aa";
		age=11;
	}
	public void showp(){
		System.out.println(name+".."+age);
	}
}
class Person2{
	private String name;
	private int age;
	
	public Person2(){			//空参构造
		System.out.println("构造方法2");
	}
	public Person2(String name,int age){	//有参构造
		this.name=name;
		this.age=age;
		System.out.println("构造方法3");
	}
	public void show(){
		System.out.println(name+".."+age);
	} 
}
class Person3{
	private String name;
	private int age;
	
	public Person3(){			//空参构造
		
	}
	public Person3(String name,int age){	//有参构造
		this.name=name;
		this.age=age;
	}
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
}
class Student{
	private String name;
	private int age;
	
	public Student(){
		
	}
	public Student(String name,int age){
		this.name=name;
		this.age=age;
	}
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age=age;
	}
	public int getAge(){
		return age;
	}
	public void show(){
		System.out.println(name+"..."+age);
	}
}

class Static_e{
	String name;			//非静态的成员变量
	static int age;			//静态的成员变量
	public void show(){
		System.out.println(name+"..."+age);
	}
}

class Notice{
	int num1=10;
	static int num2=20;
	public void show1(){	//非静态的成员方法，既可以访问静态的成员也可以访问非静态的成员		
		System.out.println(num1);
		System.out.println(num2);
	}
	public static void show2(){	//静态的成员方法，只能访问静态的成员变量		
		//System.out.println(num1);			无法从静态上下文中引用非静态的变量
		System.out.println(num2);
	}
}