第七章 Java类和对象_java中同一个类的不同对象是完全独立的个体，他们分别拥有各自的属性-CSDN博客

public class Person {

	//定义属性
	String name;
	String sex;
	int age;
	
	//定义方法
	public void eat(){
		System.out.println("人在吃东西！");
	}
	
	public void say(String language){
		System.out.println("人在说" + language + "话！");
	}
}

public class Test {
	public static void main(String[] args) {
		//创建Person类的对象，或者说实例化Person类
		Person person = new Person();
		//类似于我们之前用的
		Scanner scanner = new Scanner(System.in);
		//调用对象的属性   对象.属性
		person.name = "张三";
		person.sex = "男";
		person.age = 20;
		System.out.println(person.name);
		//调用对象的方法  对象.方法
		person.eat();
		person.say("中国");
	}
}

总结，类和对象的使用：

创建类，设计类的成员
创建类的对象

通过“对象.属性”或“对象.方法”调用对象的结构

体会类的多个对象的关系

一个类是可以创建多个对象的
这多个对象每个对象都拥有独立的一套属性和方法
修改某个对象的属性a，不会影响其他对象的属性a
我们定义的类是属于引用类型！！！这就意味着对象内容是在堆区，而引用是在栈区，栈区保存的是对象在堆区中的地址值！

public class Test {
	public static void main(String[] args) {
		//创建Person类的对象，或者说实例化Person类
		Person person = new Person();
		
		//类似于我们之前用的
		Scanner scanner = new Scanner(System.in);
		
		//调用对象的属性   对象.属性
		person.name = "张三";
		person.sex = "男";
		person.age = 20;
		
		System.out.println(person.name);
		
		//调用对象的方法  对象.方法
		person.eat();
		person.say("中国");
		
		/*
		 * 如果创建了一个类的多个对象，则每个对象都拥有独立的一套属性和方法。
		 * 意味着：如果我们修改了某个对象的属性a，不会影响到另一个对象的属性a。
		 */
		Person person2 = new Person();
		System.out.println(person2.name);
		System.out.println(person2.sex);
		
		
		//其实是将person中保存的地址值给了person3，那目前person和person3其实指向的是同一个对象
		Person person3 = person;
		System.out.println(person3.name);
		
		person3.age = 50;
		System.out.println(person.age);
	}
}

对象的内存解析

public static void main(String[] args) {
Person per = new Person();
per.name = "老雷";

Person per1 = per;
per1.name = "小强";
System.out.println(per.name);
}

成员变量（属性）和局部变量的对比

相同点：

他们都是变量
定义变量的格式：数据类型变量名 = 变量值
先声明后使用
变量都有其对应的作用域

不同点：

在类中声明的位置不同
成员变量：直接定义在一对{}内
局部变量：声明在方法内、方法形参、代码块、构造器形参、构造器内部
关于权限修饰符的不同
成员变量：声明时，使用权限修饰符指明其权限。（权限修饰符有：private、缺省、protected、public）
局部变量：不可以使用权限修饰符
默认初始化值的情况
成员变量：根据其类型，都有默认初始的值
整型：0
浮点型：0.0
字符型：ASCII码值是0的那个字符
布尔型：false
引用类型：null
局部变量：没有默认初始化值，使用前，一定要初始化赋值才行。
在内存中存放的位置
属性：存放在堆空间
局部变量：存放在栈空间

匿名对象的使用

理解：我们创建的对象，没有显式的赋给一个变量名，即为匿名对象
特征：匿名对象只能调用一次

public class Test8 {
	public static void main(String[] args) {
		//匿名对象的使用
		new Person().eat();
	}
}

方法的重载

概念：在同一个类中，可以存在多个同名方法，只要它们的参数个数或者参数类型不同即可
特点：与返回值类型无关，只看参数列表，参数列表必须不同。（参数个数或参数类型）。调用时，根据方法参数列表的不同来区别。

public class Test {
	
	//如下的几个方法是属于方法的重载
	public static int sum(int num1, int num2){
		return num1 + num2;
	}
	
	public static double sum(double num1, double num2){
		return num1 + num2;
	}
	
	public static void sum(int num1, double num2){
		System.out.println(num1 + num2);
	}
}

封装

封装是面向对象特征之一
设计程序追求“高内聚，低耦合”
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅对外暴露少量的方法用于使用
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

public class AnimalTest {
	public static void main(String[] args) {
		Animal a1 = new Animal();
		a1.name = "大黄";
//		a1.age = 5;
//		a1.age = -2;//因为目前年龄是外界都能直接访问到的，所以可以随便赋值，甚至不合理的值。所以我们可以提供一个方法去给年龄赋值，
		//同时呢，又别让外界直接能访问到年龄。
		a1.setAge(3);
		a1.show();
	}
}

class Animal{
	String name;
	private int age;
	
	//对属性的赋值
	public void setAge(int a){
        age = a > 0 ? a : 0;
	}
	//对属性的获取
	public int getAge(){
		return age;
	}
	//提供关于name的get和set方法
	public String getName(){
		return name;
	}
	public void setName(String n){
		name = n;
	}
	public void show(){
		System.out.println("name:" +name + ", age:" + age);
	}
}

Java中封装，其实就是做以下操作：

将所有的成员变量(属性)用private来修饰。private-私有的
提供关于每个属性的set和get方法

四种权限修饰符

Java权限修饰符public、protected、private置于类的成员定义之前，用来限定对象对该类成员的访问权限。

修饰符	类内部	同一个包	不同包的子类	同一个工程
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√