构造方法以及static关键字

Student s = new Student() ；  这行代码都做了哪些事？从内存角度分析

1）加载Student.class进内存

2）在栈内存中开辟内存空间

3）在堆内存中申请空间

4）对数据进行初始化

​	4.1）系统默认初始化 

​	4.2）显示初始化-setxx(形参)/构造方法赋值

5）堆内存申请空间完毕，产生一个堆内存地址

6）将堆内存地址赋值给变量S

7）栈内存变量S指向堆内存地址
构造方法：就是给对象中的数据初始化
1）方法名和类名相同
2）没有具体的返回值类型，连void也没有
构造方法的注意事项
1）在一个类中，如果我们不写无参构造方法，系统会默认提供一个无参构造方法
2）如果我们提供一个有残构造方法，系统就不会再提供无参了，如果使用无参构造方法创建对象就会报错。

带参数构造参数为属性赋值

class Student{
	//创建属性(成员变量)
	private String name ;
	private int age ;
	private String gender ;
	private String faxing ;
	//创建构造方法
	public Student(){
	}
	public Student(String name ,int age ,String gender ,String faxing){
		this.name = name ;
		this.age = age ;
		this.gender = gender ;
		this.faxing = faxing ;
	}
	//返回值方法
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
	public String getGender(){
		return gender ;
	}
	public String getFaXing(){
		return faxing ;
	}
	//成员方法    吃饭，抽烟，打游戏，学习Java
	public void eat(){
		System.out.println("早餐还是要吃的");
	}
	public void smoke(){
		System.out.println("抽烟对身体不好");
	}
	public void playGame(){
		System.out.println("可以适当的玩游戏，但不要沉迷呦");
	}
	public void study(){
		System.out.println("热爱学习");
	}

}
//创建测试类
class StudentTest{
	public static void main(String[] args){
		//创建对象
		String name ;
	
		Student s = new Student("张三",20,"男","小平头");
		System.out.println("姓名:"+s.getName()+" 年龄:"+
							s.getAge()+" 性别:"+s.getGender()+" 发型是:"+s.getFaXing());
		s.eat();
		s.smoke();
		s.playGame();
		s.study();
	}
}

使用setxxx/getxxx来赋值并返回值

class Animal{
	//创建属性私有化
	private String name ;   //姓名
	private int age ;       //年龄
	private String color ;	//颜色
	//提供对外的公共访问方法
	public void setName(String name){
		this.name = name ;
	}
	public void setAge(int age){
		this.age = age ;
	}
	public void setColor(String color){
		this.color = color ;
	}
	//获取返回值
	public String getName(){
		return name ;
	}
	public int getAge(){
		return age ;
	}
	public String getColor(){
		return color ;
	}
}
//定义一个测试类AnimalTest
class AnimalTest{
	public static void main(String[] args){
		//创建一个类对象
		Animal a = new Animal();
		a.setName("二哈");
		a.setAge(3);
		a.setColor("棕色");
		System.out.println("姓名是"+a.getName()+"年龄是"+a.getAge()+"岁"+"颜色是"+a.getColor());
	}
}

static关键字：就是累变量，随类的加载而加载，优于对象存在
1）被static修饰的变量/方法，都随着类的加载而加载
2）被static修饰过，优先于对象存在
3）被static修饰过，可以被多个对象共用
4）被静态修饰的成员变量或成员方法，可以被类名直接访问（推荐使用），也可以用该类对象来访问
static使用的注意事项
1）在static中，没有this关键字的，原因是this是代表当前类的对象的地址，对象已经创建了，而static修饰和类有关系
2）关于成员方法访问：
a.非静态：既可以访问静态变量/方法，也可以访问非静态变量/方法。
b.静态：只能访问静态变量/方法，不能访问非静态变量/方法。

/自定义一个类
class Demo2{	
	//定义一个成员变量
    int num = 100 ;
	//静态成员变量
	static int num2 = 200 ;
	//成员方法
	public void show(){
		System.out.println(num2) ;
		System.out.println(num) ;
	}
	//成员方法
	public void method(){
		show() ;
		function() ;
	}
	//静态的成员方法
	public static void function(){
		System.out.println("这是静态的function方法...") ;
	}
	//静态的成员方法
	public static void function2(){
		System.out.println(num2) ;
		//System.out.println(num) ; //编译出错 无法从静态上下文中引用非静态 变量 num
		//show() ; 编译会出错 无法从静态上下文中引用非静态方法 show()
		function() ;
	}
}
//测试
class StaticDemo2{
	public static void main(String[] args){
		//创建Demo2类的对象
		Demo2 d = new Demo2() ;
		d.show() ;   //200   100
		System.out.println("-------------------------") ;
		d.method() ;  //200  100  这是静态的function方法...
		System.out.println("-------------------------") ;
		d.function2() ;
		System.out.println("-------------------------") ;
		//调用sum()方法
		int result = sum(10,20) ; //静态只能访问静态!
		System.out.println(result);
	}
	//求两个数据之和
	//public int sum(int a,int b)     编译报错  无法从静态上下文中引用非静态 方法 sum(int,int)
	public static int sum(int a,int b){
		return a + b ;
	}
}