面向对象、类与对象、构造器、封装

构造方法：

* 1.如果该类中没有写构造方法，则有一个默认公共的无参的构造方法
 * 
 * 2.一旦编写了构造方法，则默认的构造方法不再提供
 * 
 * 3.构造方法没有返回值，连void都没有
 * 
 * 4.构造方法的方法名必须和类名一致（不管是无参还是有参，都要跟类名一致）
 * 
 * 5.构造方法不需要进行调用，当创建对象时，会自动调用构造方法进行数据初始化
 * 
 * 语法 ：权限控制修饰符 方法名（参数名）{方法体}
 * @author 涛涛涛
 * @time 2024年1月22日

类和对象：

 对象：

 * 
 * 1 内存角度 : 封装数据的一种形式
 * 
 * 2 代码角度 : new  的一个类的实例对象
 * 
 * 3 人类认知角度 : 具体的个体就是对象,所以一切皆对象
 * 

类：

 * 类 : 对某个事物进行的客观描述
 * 
 * 类就是根据某个事物,抽象出来的属性封装
 * 
 * 对象是属性值的封装,代表某类的一个个体
 * 
 * 根据不同的属性,封装不同的类
 * 
 * 根据不同的属性值,封装不同的对象
 

先建一个外部学生类（外部内部都可以，个人觉得写到外部更简洁一些，写道内部就是方便直接调，好看见），注意里面的注释！！！

/**
 * 学生类，根据学生特征，抽象的类
 * @author 涛涛涛
 * @time 2024年1月22日
 */
public class Student {
	// 如果该属性是类对象共有的属性和值，定义为静态变量
	// 如果该属性是类对象共有的属性,值可能不一样,定义为成员变量
	// 如果该方法中有成员属性使用(直接使用,不需要对象),则该方法为成员方法(静态方法中不能直接使用成员属性)
	// 如果该方法中不需要有成员属性使用,则该方法为静态方法
	//学号
	int id;
	//姓名
	String name;
	//性别
	char sex;
	//住址
	String addr;
	public void m1(){
		System.out.println(name);
	}
	public Student(int id_, String name_, char sex_, String addr_) {
		id = id_;
		name = name_;
		sex = sex_;
		addr = addr_;
	}
	
//	public static void m2(){
//		System.out.println(Student.name);
//	}
/*
 *    程序最终都将在内存中执行，变量和方法只有在内存中占有一席之地时才能被访问。
 * 类的静态变量和静态方法属于类本身，在类加载的时候就会分配内存，可以通过类名直接去访问；
 * 非静态变量和非静态方法属于类的对象所有，所以只有在类的对象产生（即创建类的实例，有对象时）时才会分配内存，
 * 然后通过类的对象（实例）去访问。在一个类的静态方法中去访问其非静态成员，
 * 等于访问一个内存中不存在的东西当然会出错 
 * */
	
}

实例化： 

 就是new一个对象。
 *             1 相关类载入方法区
 *             2 new 会在堆内存开辟内存空间
 *             3 调用构造方法，在栈内存开辟栈帧，执行构造方法对堆内存空间值进行初始化赋值
 *             4 构造方法执行完之后，构造方法弹栈，把堆内存地址赋值给变量s1

public class OOP_02 {
	public static void main(String[] args) {
		//数据类型 变量名 = 值
		//类，数组，接口
		//创建一个引用类型变量，保存一个类对象
		Student s1 = new Student(1001, "张三1", '男', "石家庄");
		Student s2 = new Student(1002, "张三2", '男', "石家庄");
		// 对象.属性
		// 对象.方法（参数）
		//修改 对象之间的数据相互不影响，修改s1不会影响到s2，因为成员属性是对象独立保存的
		s1.name = "李四";
		//查询
		System.out.println(s1.name);
		System.out.println(s2.name);
	}
}

JavaBean   （初涉一点点）：

为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性，set和get方法获取。

先暂时知道成员变量私有，set和get方法获取即可。

写一个User类：

//JavaBean

public class User {
	private String username;
	private String password;
	private String nickname;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		//当局部变量和成员变量同名，可以使用this进行区分
		//this.username 指的是成员变量的那个username
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	public String getNickname() {
		return nickname;
	}
	public void setNickname(String nickname) {
		this.nickname = nickname;
	} 
	//全参构造
	public User(String username, String password, String nickname) {
		this.username = username;
		this.password = password;
		this.nickname = nickname;
	}
	//无参构造
	public User(){
		
	}
	
	

}

常见异常：

//java.lang.NullPointerException
// 空指针异常 : 使用null值,访问成员属性时,会出现空指针异常
//这个空指针异常一般有可能时数据库或者别的需要给我们的返回的，要注意

public class OOP_03 {
	public static void main(String[] args) {
		//创建用户对象
		User user = new User("admin","root","管理员");
		System.out.println(user.getUsername());
		user = null;
		//java.lang.NullPointerException
		// 空指针异常 : 使用null值,访问成员属性时,会出现空指针异常
		//这个空指针异常一般有可能时数据库或者别的需要给我们的返回的，要注意
		//System.out.println(user.getPassword());
	}
}

对象调用静态属性:

        尽管s1是null，但是可以访问静态变量，静态变量的访问是通过类名访问的，同类可省，他们在不同类里面，前面要加类名.，这里他只是让s1这个对象为空了，对象在堆内存，但是静态变量在方法区，不是空，s1是空，但是跟Star这个类没有关系，仍然能通过Star.这个类名来访问，实际上，即使那里写了s1， 反编译之后，其实就是Star。

        也就是说，如果是对象调用的静态属性，则在编译后，会把对象转换为对应的类名去调用。

public class OOP_04 {
	public static void main(String[] args) {
		Star s1 = new Star(15);
		s1 = null;
		//System.out.println(s1.age);
		//s1已经为null了，访问不到成员变量了
		
		System.out.println(s1.i);
		/*尽管s1是null，但是可以访问静态变量，静态变量的访问是通过类名访问的，同类可省，他们在不同类里面，
		 前面要加类名.，这里他只是让s1这个对象为空了，对象在堆内存，但是静态变量在方法区，不是空，
		 s1是空，但是跟Star这个类没有关系，仍然能通过Star.这个类名来访问，实际上，即使那里写了s1，
		 反编译之后，其实就是Star
		*/
		
		Star s2 = new Star(15);
		Star s3 = new Star(15);
		s2.age = 20;   //成员变量修改    成员变量修改，多个对象也相互不影响
		System.out.println(s2.age);  //本来输出都是15，在成员变量修改后，这里输出是20
		System.out.println(s3.age);  
		
		//静态变量修改后，所有对象都会变成修改之后的那个值
		//如果是对象调用的静态属性，则在编译后，会把对象转换为对应的类名去调用
		s2.i = 3;
		System.out.println(s2.i);
		System.out.println(s3.i);
		System.out.println(Star.i);
		
	}
}

对象是传引用类型

public class OOP_05 {
	int age = 2;
	public static void main(String[] args) {
		OOP_05 obj = new OOP_05();
		m1(obj);
		//对象是属于引用类型的传递，如果不写上面的m1，obj.age的值仍然是2
		System.out.println(obj.age);
	}
	public static void m1(OOP_05 obj){
		obj.age++;
		System.out.println(obj.age);
	}
}