面向对象复习（一）

类和对象的关系

类 对现实世界中事物的描述(成员变量和方法)

对象 现实世界中实际存在具体的个体

对象即是该类事物实实在在存在的个体。

拿我们自己打比方，人就是一个类(是把每一个相同属性行为的对象进行抽取)

人的属性:姓名,年龄,身高,体重等

人的行为:吃饭,睡觉,说话,跑,跳等

而我们就是对象(是实实在在存在的个体),具体每个人叫什么名字,年龄多大,身高多高,体重多重等,吃饭怎么吃,睡觉怎么睡,说话怎么说等描述任意一类事物就是在描述他的属性和行为

创建对象并使用

public class 成员变量和成员方法 {
	public static void main(String[] args) {
		/*
		* 创建对象并使用
		* 格式：类名 对象名 = new 类名();
		* 使用成员变量：对象名.变量;
		* 使用成员方法：对象名.方法名();
		*/

		Student s = new Student();				//创建对象 ,创建对象在最后有小括号
		//String name = s.name;					//获取对象的属性(成员变量)
		//int age = s.age;
		//char gender = s.gender;
		s.name = "张三";                       //获取对象中的属性并赋值,调用属性的时候后面没有括号
		s.age = 23;
		s.gender = '男';

		s.study();								//获取对象的行为(成员方法)
		s.sleep();                              //调用方法的时候后面有括号

		s.name = "李四";
		s.study();
	}
}


class Student {
	/*
	* 属性:姓名,年龄,性别(成员变量)
	* 行为:学习,睡觉(成员方法)
	*/

	String name ;
	int age ;                         //成员变量  ，定义在类中方法外
	char gender ;

	public void study(int x) {                  //局部变量，定义在方法上
		int age = 30;                           //局部变量 ，定义在方法中
		System.out.println(age);               //这里输出30 因为在Java中有就近原则
		System.out.println(name + "在学习");
	}

	public void sleep() {
		System.out.println(name + "在睡觉");
	}
}

成员变量和局部变量的区别

A:在类中的位置不同
    成员变量：在类中方法外
    局部变量：在方法定义中或者方法声明上
B:在内存中的位置不同
     成员变量：在堆内存(成员变量属于对象,对象进堆内存)
     局部变量：在栈内存(局部变量属于方法,方法进栈内存)
C:生命周期不同
     成员变量：随着对象的创建而存在，随着对象的消失而消失
     局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值不同
     成员变量：有默认初始化值
    局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。
    局部变量不被对象所调用。成员变量被对象调用。
注意事项：
    局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
    

class Test1 {
	public void run(Student s) {			//参数是引用数据类型,调用这个方法时传递的是该类的对象
		System.out.println("run");
	}<p><span style="color:rgb(51, 51, 51);">方法的参数是类名</span><span style="color:rgb(51, 51, 51);">：</span><span style="color:rgb(51, 51, 51);">如果看到了一个方法的形式参数是一个类类</span><span style="color:rgb(51, 51, 51);">名</span><span style="color:rgb(51, 51, 51);">(引用类型)，这里其实需要的是该类的对象。</span></p><p><span style="color:#333333;">方法的返回值是类名：如果看到一个方法的返回值是类名，这里需要返回的是该类的对象</span></p>
	public Student aaa() {					//返回值类型是引用数据类型,返回的就是该类对象
		Student s = new Student();			//s = 0x0022
		return s;

匿名对象

匿名对象就是没有名字的对象    new student();

匿名对象可以调用属性但没有意义

匿名对象可以调用方法，适合对某一方法单次调用时使用，如果调用多次要用有名字的对象，因为new的对象占内存

匿名对象可以当参数传递，节省代码

封装

 封装概述：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
 封装好处
      隐藏实现细节，提供公共的访问方式
      提高了代码的复用性
      提高安全性。
 封装原则
     将不需要对外提供的内容都隐藏起来。
     把属性隐藏，提供公共方法对其访问。

  private关键字特点
     a:是一个权限修饰符
     b:可以修饰成员变量和成员方法
     c:被其修饰的成员只能在本类中被访问

    把成员变量用private修饰
    提要对应的getXxx()和setXxx()方法
    private仅仅是封装的一种体现形式,不能说封装就是私有

class Person {
	private String name;
	private int age;

	//变量名要求见名只意
	public void setName(String name) {	
		this.name = name;		//this代表当前对象的引用
	}					//局部变量绝对不能用对象.调用

	public String getName() {
		return name;
	}

	public void setAge(int a) {
		age = a;
	}

	public int getAge() {
		return age;
	}

	public void print() {
		System.out.println("print方法中的:" + this);
		method();
	}

	public void method() {
		System.out.println("method");
	}
	/*
	this可以用来区分成员变量和局部变量重名,用this.调用的是成员变量
	this可以调用成员方法
	*/
}

构造方法
      方法名与类名相同(大小也要与类名一致)
     没有返回值类型，连void都没有
     没有具体的返回值
       一创建对象就执行，不用调用
     注意事项： 

 1.如果在一个类中没有定义构造方法,系统会默认给一个空参的构造方法

格式是:public 类名(Student)(){}
2,如果定义有参构造函数,没有定义空参构造函数,系统不会默认再给空参构造函数
3,空参什么用,有参什么用?
a 有参的构造函数就是为了给对象中的属性进行初始化用的
b 空参在不需要给属性进行初始化,但是还要创建对象的时候使用
4,定义了有参构造函数,要不要再定义空参的呢?
建议把空参的加上,为了创建对象,调用成员使用

public static void main(String[] args) {
		//Student s = new Student();
		
		Student2 s2 = new Student2("李四",24);
		s2 = new Student2("李五",25);			//新对象将原来对象的地址值覆盖,原对象变成垃圾
	}

}
class Student2 {
	private String name ;
	private int age;
	//无参构造创建对象时使用
	public Student2() {    //构造方法给成员变量进行初始化
	    //name = "zhangsan";
		//age = 23;
		super();
		
	}
	public Student2(String name, int age) {//有参构造，给对象中的属性进行初始化使用
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		/*
		构造方法和setXxx方法的区别
		1,构造方法是用来给对象中的属性进行初始化的
		2,setXxx是用来修改属性值的,在原对象的基础上
		*/
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	

静态

    static关键字的特点
 a:随着类的加载而加载
 b:优先于对象存在
 c:被类的所有对象共享
 d:可以通过类名调用
 其实它本身也可以通过对象名调用
   static的注意事项
 a:在静态方法中是没有this关键字的
  静态是随着类的加载而加载，this是随着对象的创建而存在。
  静态比对象先存在。
 b:静态方法只能访问静态的成员变量和静态的成员方法
 静态方法：
  成员变量：只能访问静态变量
  成员方法：只能访问静态成员方法
 非静态方法：
  成员变量：可以是静态的，也可以是非静态的
  成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
 简单记：
  静态只能访问静态。
静态变量和成员变量的区别：
 A:所属不同
 静态变量属于类，所以也称为为类变量
  成员变量属于对象，所以也称为实例变量(对象变量)
 B:内存中位置不同
  静态变量存储于方法区的静态区
  成员变量存储于堆内存
 C:内存出现时间不同
  静态变量随着类的加载而加载，随着类的消失而消失
  成员变量随着对象的创建而存在，随着对象的消失而消失
 D:调用不同
  静态变量可以通过类名调用，也可以通过对象调用
  成员变量只能通过对象名调用

public static void main(String[] args) {
		//Test t = new Test();
		//t.print1();静态变量也叫类变量  成员变量也叫对象变量
		

		Test.print2();
		//method();								//method方法是静态的,直接能调用,是因为系统会默认加上类名.
		Demo2Static.method();
	}

	public static void method() {
		System.out.println();
	}
}

class Test {
	int num1 = 10;
	static int num2 = 20;

	/*public void print1() {					//非静态的成员方法可以访问静态的成员
		System.out.println(num1);
		System.out.println(num2);
	}*/

	public static void print2() {				//静态方法不能访问非静态的成员
		//System.out.println(this.num1);
		System.out.println(num2);				//静态只能访问静态
	}

Math类的随机数功能

/* A:Math类概述
	* 类包含用于执行基本数学运算的方法
* B:Math类特点
	* 由于Math类在java.lang包下，所以不需要导包。
	* 没有构造方法，因为它的成员全部是静态的。
* C:获取随机数的方法
	* public static double random():返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
* D:我要获取一个1-100之间的随机数，肿么办?
	* int number = (int)(Math.random()*100)+1;*/
	public static void main(String[] args) {
		//需求：猜数字小游戏(数据在1-100之间)
		for (int i = 0; i < 100; i++) {//遍历随机生成的100个数
			int num = (int)(Math.random()*100)+1;//生成随机数
			System.out.println(num);
		}