Java学习笔记_类和对象

·类：是一组相关属性和行为的集合，可以看成是一类事务的模板，使用事物的属性特征和行为特征来描述该类事物。
·属性：该事物的状态信息
·行为：就是该事物能够做什么

·对象：一类事物的具体体现，对象是类的一个实例，必然具备该类事物的属性和行为。

成员变量：
String name;
int age;

成员方法：
public void eat( ){ }
public void sleep( ) { }

注意事项：

1. 成员变量直接定义在类当中，在方法外面
2. 成员方法不要写static关键字

public class Student {
String name;
int age;

public void eat() { 
	System.out.println(“吃饭”)
}

public void sleep() { 
	System.out.println(“睡觉”)
}

public void study() { 
	System.out.println(“学习”)
}

}

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用

1. 导包：也就是指出需要使用的类，在什么位置
   import 包名称.类名称
   对于和当前类属于同一个包的情况，可以省略导包语句不写

2. 创建，格式
   类名称 对象名 = new 类名称();
   Student stu = new Student();

3. 使用
   使用成员变量：对象名.成员变量名
   使用成员方法：对象名.成员方法名（参数）

public class Demo{
	public static void main(String[] args){
		Student stu = new Student();
		
		System.out.println(stu.name);
		System.out.println(stu.age);

		stu.name = “zhangsan”
		stu.age = 18;
		
		System.out.println(stu.name);
		System.out.println(stu.age);

		stu.eat();
		stu.sleep();
		stu.study();
		
	}
}

public class Phone{
	String brand;
	double price;
	String color;

	public void call(String who){
		System.out.println(“给” + who + “打电话”)；
	}

	public void sendMessage(){
		System.out.println(“群发短信”)；
	}
}

public static void main(String[] args){
	Phone one = new Phone();
	System.out.println(one.brand);
	System.out.println(one.price);
	System.out.println(one.color);

	one.brand = “苹果”；
	one.price = 8388.0；
	one.color = “黑色”；
	System.out.println(one.brand);
	System.out.println(one.price);
	System.out.println(one.color);

	one.call(who:”乔布斯”)；
	one.sendMessage();
	}

局部变量和成员变量

1. 定义的位置不一样
   局部变量：在方法内部
   成员变量：在方法外部，直接写在类当中

2. 作用范围不一样
   局部变量：只有方法当中才可以使用，出了方法就不能再用
   成员变量：整个类全部可以通用

3. 默认值不一样
   局部变量：没有默认值，如果想要使用，必须手动进行赋值
   成员变量：如果没有赋值，会有默认值，规则和数组一样

4. 内存的位置不一样
   局部变量：位于栈内存
   成员变量：位于堆内存

5. 生命周期不一样
   局部变量：随着方法进栈而诞生，随着方法出栈而消失
   成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

public class Demo{
	String name;//成员变量
	public void methodA(){
		int num = 20;//局部变量
		System.out.println(num);
		System.out.println(name);
	}

public void methodB(int param){
	//方法的参数就是局部变量
	//参数在方法调用的时候，必然会被赋值
	System.out.println(param);

	int age;//局部变量
	System.out.println(age);//没赋值不能用
	System.out.println(num);//错误写法
	System.out.println(name);
	}
}

面向对象的三大特征：封装、继承、多态

封装性在Java中的体现：

1. 方法就是一种封装
2. 关键字private也是一种封装

封装就是将一些信息隐藏起来，对于外界不可见

public class Demo{
	public static void main(String[] args){
		int[] array = {5,15,25,20,100};
		int max = getMax(array);
		System.out.println(“最大值：” + max)}
		//给我一个数组，我还给你一个最大值
		public static int getMax(int[] array){
			int max = array[0];
			for(int i = 1;i < array.length; i++){
				if(array[i] > max){
					max = array[i];
				}
			}
			return max;
		}
}

问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来
解决方案：用private关键字将需要保护的成员变量进行修饰。

一旦使用了private进行修饰，那么本类当中仍然可以随意访问，
但是，超出了本类范围之外就不能再直接访问了。

间接访问private成员变量，就是定义一对Getter/Setter方法

必须是setXxx或者getXxx命名规则
对于Getter来说，不能有参数，返回值类型和成员变量对应
对于Setter来说，不能有返回值，参数类型和成员变量对应

对于基本类型中的boolean值，Getter方法一定要写成isXxx的形式，
而setXxx规则不变。

public class Person{
	String name;
	private int age;

	public void show(){
		System.out.println(“我叫：” + name + “，年龄：” + age);
	}
	//这个成员方法，专门向age设置数据
	public void setAge(int num){
		if(num < 100 && num >= 0){
			age = num;
		}else{
			System.out.println(“数据不合理！”)；
		}
	}
	//这个成员方法，专门私有获取age的数据
	public int getAge(){
		return age;
	}
}

public boolean isMale(){
	return male;
}

当方法的局部变量和类的成员变量重名的时候，根据就近原则，优先使用局部变量。
如果需要访问本类当中的成员变量，需要使用格式：
this.成员变量

”通过谁调用的方法，谁就是this”

public class Person{
	String name;
	//参数name是对方的名字
	//成员变量name是自己的名字
	public 	void sayHello(String name){
		System.out.println(name + “,你好，我是” + this.name);
		}
}

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。
格式：
public 类名称（参数类型 参数名称）{
方法体
}

注意事项：

1. 构造方法的名称必须和所在类名称完全一样，就连大小写也要一样
2. 构造方法不要写返回值类型，连void都不写
3. 构造方法不能return一个具体的返回值
4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做
5. 一旦编写了至少一个构造方法，那么编译器将不再赠送
6. 构造方法也是可以进行重载的（方法名称相同，参数列表不同）

public class Student{
	public Student(){
		System.out.println(“构造方法执行”)；
	}

	public Student(String name,int age){
		this.name = name;
		this.age = age;
	}
}