Java基础学习之 构造方法 静态方法与变量 简单的面向对象应用

一 构造方法的注意事项

1.先看一个程序：

public class Demo01 {
	public static void main(String[] args) {
		car car = new car();
		car.setName("奥迪双钻");
		car.setCar("骚粉");
		car.says();
	}
}
  class car{
	  private String name;
	  private String color;
	  public car(){
		  System.out.println("无参");
	  }
	  //写个有参构造方法
	  public car(String name,String color) {
		  this.name = name;
		  this.color=color;
	  }
	  
	  public void says() {
		System.out.println(this.name+" "+this.color);
	}
	  
	  public void setName(String name) {
		  this.name = name;
	  }
	  public void setColor(String color) {
		  this.color = color;
	  }
	  public String getName() {
		  return name;
	  }
	  public String getColor() {
		  return color;
	  }
	  
  }

在上面例子中存在无参构造方法,如果一个类中没有明确定义一个无参构造方法系统会在你创建对象的同时也调用无参构造;这个无参构造方法系统会自动提供. 如果只定义有参构造方法 ,系统则不会自动创建无参构造方法.

2.修改成员变量的方式:

2.1调用set方法

2.2 调用有参构造方法

2.3重新指定一个对象

car = new car("法拉第","逗比粉"); 此时系统在内存中再次开辟一块空间 占用内存不建议使用 

二 静态变量

静态变量(相当于一个共享的变量  每个对象都能访问到)

需要关键词 static 修饰 

看例子:

public class Demo03 {
	public static void main(String[] args) {
		AVGirl avGirl = new AVGirl();
		avGirl.name ="波多野结衣";
//		avGirl.country = "japan";
		AVGirl.country = "japan";  // static 修饰的变量建议使用类名直接调用;
		avGirl.sayhi();
		
		AVGirl avGirl2 = new AVGirl();
		avGirl2.name  = "小仓";
//		avGirl2.country = "japan";   //static 修饰的变量可以使用对象直接调用(不建议)
		avGirl2.sayhi();
	}

}
class AVGirl{
	 String name;
	 static String country;
	 
	 // 构造方法能用private修饰 并且有特殊用途
	/* private AVGirl() {
		 
	 }*/
	 
	public void sayhi() {
		System.out.println("我是"+name+"我来自"+country);
	}
}

对象加载在内存中的表现步骤:

1.加载有main类的.class 文件到方法区中

2. main方法入栈(创建对象)

3.先把AVGirl.class加载到 方法区中; 然后在堆内存中开辟空间 创建AVGirl对象

4.赋值方法入栈  出栈

5.main方法执行完毕 出栈

6.程序结束

  static 修饰后的成员变量转化成静态变量 存放在方法区的静态区中随类的创建创建,既可以被类调用也能被对象调用,但是一般不建议用对象调用,为了区别与成员变量的调用. 因为 静态变量创建好时 对象还没实例化.

  静态变量的好处:

节约内存(静态变量 是一个共享的变量)

  静态变量与成员变量的区别:

1.所属不同

 静态变量:属于类 也叫类变量

 成员变量:属于对象 也叫对象变量(实例变量)

2.在内存中所处的位置不同

 静态变量: 方法区的静态区

 成员变量: 在堆内存中

3.在内存中加载时机不同(生命周期)

 静态变量:随着类的加载而加载  随着类的销毁而销毁(程序结束);

 成员变量:随着对象的创建而创建 随着对象的销毁而销毁

4.调用方式不同

 静态变量: 对象名 和 类名(建议)

 成员变量: 只能使用对象名.

三 静态方法

在text 类中

成员方法 fun1

静态方法 static修饰方法 fun2 fun3

class text{
	int num1 = 10;
	static int num2 = 20;
	
	public void fun1() {
		System.out.println(num1);
		System.out.println(num2);
		fun2();
	}
	public static void fun2() {
		//局部变量
		int hei = 10;
		int lei =10;
		/*System.out.println(num1);
		System.out.println(num2);*/
		
		System.out.println(hei);
		System.out.println(lei);
		fun3();
	}
	public static void fun3() {
		System.out.println("我是fun3");
	}
}

成员方法:

     成员方法中既可以使用成员变量也可以使用静态变量  

静态方法:

    随着类的加载而加载(跟静态变量一样)

    静态方法的执行 跟 成员方法一样 入栈和出栈.

    静态方法中不能使用成员变量 因为静态方法加载时还没有对象 只能使用静态变量

简单来说就是 静态只能调动静态的 成员的既能调用成员的也能调用静态的.

四 简单的面向对象应用实例

需求:

 设计类 完成 剪刀 石头 布  游戏

 人和电脑之间的

 人 从键盘输入  石头 剪刀 布

 电脑 随机出拳

 根据游戏规则 判断输赢 打印

思路:

1.设计类(看看完成这个功能要几个类)

2.设计类中的方法和属性

 人 类  

   出拳的方法

电脑 类 

   出拳的方法

规则 类(比较)

  比较结果的方法

游戏开始 类(组合前3个类的逻辑)

   游戏开始的方法(组装前面的方法 让游戏开始)

测试类

        创建游戏开始类对象  调用开始方法

人类:

public class Person {
	//人出拳的方法  : 把出拳的字符串转化成 数字 
	//方便之后的判断
	public int punches() {
		System.out.println("请输入石头 剪刀 布");
		Scanner scanner = new Scanner(System.in);
		// 接收出拳的字符串
		String punch = scanner.nextLine();
		// 把出拳的字符串转化成 数字 
		int num=0;
		switch (punch) {
		case "石头":
			num = 1;
			System.out.println("人出的是"+ punch);
			break;
		case "剪刀":
			num = 2;
			System.out.println("人出的是"+ punch);
			break;
		case "布":
			num = 3;
			System.out.println("人出的是"+ punch);
			break;

		default:
			System.out.println("你的输入不符合,请重来");
			break;
		}
		// 返回出的拳
		return num;
	}

}

电脑类:

public class Computer {
	public int punches() {
		//随机数[1,3]
		int random = (int)(Math.random()*(3-1+1)+1);
		// 定义一个字符串来保存出的拳
		String string = " ";
		switch (random) {
		case 1:
			string = "石头 ";
			break;
		case 2:
			string = "剪刀 ";
			break;
		case 3:
			string = " 布";
			break;

		default:
			break;
		}
		System.out.println("电脑出的是"+string);
		// 返回出的拳
		return random;
	}
	
}

比较类:

public class Compare {
	//比较方法
	 public void compare(int pnum,int cnum) {
		 int c = pnum - cnum;
		if (c==-1||c==2) {
			System.out.println("你赢了");
		}else if(c==0) {
			System.out.println("你不输不赢");
		}else {
			System.out.println("你输了");
		}
	}
}

游戏类

public class Game {
	//一局一胜的游戏
	// 游戏开始的方法 (组装前面几个类的方法)
    	public void start() {
    		int n=0;
    		do {
    			// 创建人 类出拳
            	Person person = new Person();
            	int pnum = person.punches();
            	   // 创建电脑 类 出拳
            	Computer computer = new Computer();
            	int cnum = computer.punches();
            	 // 创建 比较 类 调用比较方法
            	Compare compare = new Compare();
            	compare .compare(pnum, cnum);
            	n++;
			} while (n==3);
    	}
}

测试类:

public class GameText {
	public static void main(String[] args) {
		Game game = new Game();
		game.start();
	}

}

通过上述实例 我们可以了解Java 是如何通过封装一个个类 来创建对象 然后来实现一个需求.