java学习笔记：面向对象

成员变量与局部变量的区别：

/*
	成员变量和局部变量的区别：
		1：在类中的位置不同
			成员变量：在类中方法外
			局部变量：在方法定义中，或者方法声明上
		2：在内存中的位置不同
			成员变量：在堆内存
			局部变量：在栈内存
		3：生命周期不同
			成员变量：随着对象的创建而存在，随着对象的消失而消失
			局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
		4：初始化值不同
			成员变量：有默认的初始化值
			局部变量：没有默认的初始化值，必须定义，赋值，然后才能使用
    注意事项：
        局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。
*/
class Variable{
	// 成员变量
	int num = 10;
	
	public void show(){
		// 局部变量
		int num2 = 20;
		
		System.out.println(num2);
	}
}

class VariableDemo{
	public static void main(String[] args){
		// 创建对象
		Variable v = new Variable();
		
		// 访问成员变量
		System.out.println(v.num);
		
		// 调用另一个类中的方法
		// 注意，一个类中的方法，是不能访问另一个类中的方法的。
		v.show();
	}
}

形式参数的问题：

/*
	形式参数的问题：
		基本类型：形式参数的改变不影响实际参数
		引用类型：形式参数的改变直接影响实际参数
*/

// 形式参数是基本类型
class Demo{
	public int sum(int a, int b){
		return a + b;
	}
}

// 形式参数是引用类型
class Student{
	public void show(){
		System.out.println("我爱学习");
	}
}
class StudentDemo{
	// 如果一个方法的形式参数是一个类类型(引用类型),这里其实需要的是该类的对象
	public void method(Student s){// 调用的时候，把main方法中的s的地址传递到了这里，Student s = new Student();
		s.show();
	}
}

class ArgsTest{
	public static void main(String[] args){
		// 形式参数是基本类型的调用
		// 创建对象
		Demo d = new Demo();
		int result = d.sum(10,20);
		System.out.println("result:"+result);
		
		// 形式参数是引用类型的调用
		// 需求：调用StudentDemo类中的method方法
		StudentDemo sd = new StudentDemo();
		// 创建学生对象
		Student s = new Student();
		sd.method(s); // 把s的地址给到了这里
	}
}

匿名对象的概述和应用：

/*
	匿名对象：就是没有名字的对象
	
	匿名对象的应用场景：
		A：调用方法，仅仅只调用一次的时候
			注意：调用多次的时候，不适合使用匿名对象
			优点：匿名对象调用完毕之后就是垃圾，可以被垃圾回收器回收
		B：匿名对象可以作为实际参数传递
*/
class Student{
	public void show(){
		System.out.println("我要坚持学习，不能放弃");
	}
}

class StudentDemo{
	public void method(Student s){
		s.show();
	}
}

class NoNameDemo{
	public static void main(String[] args){
		// 带名字的调用
		Student s = new Student();
		s.show();
		
		// 匿名对象的调用方法
		new Student().show();
		new Student().show(); // 这里其实是重新创建了一个新的对象
		
		// 匿名对象作为实际参数传递
		StudentDemo sd = new StudentDemo();
		sd.method(new Student());
	}
}

封装概述：

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

/*
	定义一个学生类：
		成员变量：name,age
		成员方法；show()方法
	
	分析：
		当我们通过对象给成员变量赋值，可以赋值一些非法的数据。所以我们需要在赋值之前对数据进行判断
		因此，我们决定在Student类中提供一个方法来对数据进行校验。但是仍然可以不调用方法赋值，可以
		直接赋值，导致我们的方法没有作用。所以。我们应该要求必须使用方法赋值，不能直接调用成员变量赋值
		
	解决办法：java提供了一个关键字 private
	private：私有的，可以修饰成员变量和成员方法
*/
class Student{
	String name;
	private int age;
	
	public void setAge(int a){
		if(a < 0 || a > 120){
			System.out.println("你给的年龄有问题");
		}else{
			age = a;
		}
	}
	
	public void show(){
		System.out.println("姓名:"+name);
		System.out.println("年龄:"+age);
	}
}

class StudentDemo1{
	public static void main(String[] args){
		// 创建学生对象
		Student s = new Student();
		s.show();
		System.out.println("-----------");
		
		// 给成员变量赋值
		s.name = "乔丹";
		// s.age = 45;  当age变量private后，会报错
		s.setAge(27);
		// 不合理数据
		s.setAge(-27); // 输出，你的年龄有问题
		s.show();
		System.out.println("-----------");
		
		
	}
}

 private关键字：

• private关键字：
  • 是一个权限修饰符
  • 可以修饰成员（成员变量和成员方法）
  • 被private修饰的成员只能在本类中使用
  • 与private对应的是public关键字。
• 最常见的应用：
  • 把成员变量用private修饰
  • 提供对应的getXxx()h/setXxx()方法

/*
	封装和private的应用：
		1：把成员变量用private修饰
		2：提供对应的getxxx方法和setxxx方法
*/
class Student{
	// 定义私有的变量，name和age
	private String name;
	private int age;
	
	// 获取值
	public String getName(){
		return name;
	}
		
	public int getAge(){
		return age;
	}
	// 赋值
	public void setName(String n){
		name = n;
	}
	
	public void setAge(int a){
		age = a;
	}
}

class StudentTest{
	public static void main(String[] args){
		Student s = new Student();
		s.setName("乔丹");
		s.setAge(25);
		String na = s.getName();
		int ag = s.getAge();
		System.out.println("姓名:"+na);
		System.out.println("年龄:"+ag);
	}
}

 this的概述与应用：

• 作用：this代表所在类的对象引用
• 记住：方法被哪个对象调用，this就代表那个对象
• 使用this：
  • 局部变量隐藏成员变量
  • 其他方法后面和super一起说

/*
	this的使用：
*/
class Student{
	// 定义私有的变量，name和age
	private String name;
	private int age;
	
	// 获取值
	public String getName(){
		return name; // 这里其实隐含了this
	}
		
	public int getAge(){
		return age;
	}
	// 赋值
	public void setName(String name){
		// this.name 代表当前类的对象调用name
		this.name = name;
	}
	
	public void setAge(int age){
		// this.age 代表当前类的对象调用age
		this.age = a;
	}
}

this的内存图：

构造方法：

/*
	构造方法：
		给对象的数据进行初始化
	构造方法格式：
		1.方法名与类名相同
		2.没有返回值类型，连void都没有
		3.没有具体的返回值
	构造方法的注意事项：
		1.如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
		2.如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
			如果想要使用无参构造方法，就必须自己给出，建议永远自己给出无参构造方法
*/
class Student{
	private String name;
	private int age;
	// 我们自定义的构造方法。
	public Student(){
		System.out.println("这是构造方法");
	}
	
	// 构造方法的重载
	public Student(String name){
		this.name = name;
	}
	
	public void show(){
		System.out.println(name+"---"+age);
	}
}

class ConstructDemo{
	public static void main(String[] args){
		// 创建对象
		Student s = new Student(); // 此处使用的就是构造方法
		s.show();
		
		// 创建对象2
		Student s2 = new Student("小明");
		s2.show();
	}
}

一个类的完整版

/*
	类的组成：
		成员变量
		成员方法
			根据返回值：
				void类型
				非void类型
			形式参数：
				空参方法
				非空参方法
		构造方法
	需求：写一个标准代码的版本
		学生类：
			成员变量：name，age
			构造方法：无参，带两个参
			成员方法：getxxx()/setxxx(),show()
	给成员变量赋值：
		A：setxxx()
		B：构造方法
	输出成员变量的方法：
		A：通过setxxx()分别获取然后拼接
		B：通过调用show()方法
*/
class Student{
	// 姓名
	private String name;
	// 年龄
	private int age;
	
	// 构造方法
	public Student(){
		
	}
	
	public Student(String name, int age){
		this.name = name;
		this.age = age;
	}
	
	public String getName(){
		return name;
	}
	
	public void setName(String name){
		this.name = name;
	}
	
	public int getAge(){
		return age;
	}
	
	public void setAge(int age){
		this.age = age;
	}
	
	// 输出所有的成员变量值
	public void show(){
		System.out.println(name+"----"+age);
	}
}

// 测试类
class StudentTest1{
	public static void main(String[] args){
		// 方式1：给成员变量赋值
		// 无参构造+setxxx()
		Student s1 = new Student();
		s1.setName("小明");
		s1.setAge(27);
		// 输出值
		System.out.println(s1.getName()+"----"+s1.getAge());
		s1.show();
		
		// 方式2：给成员变量赋值
		// 构造方法
		Student s2 = new Student("小李",30);
		// 输出值
		System.out.println(s2.getName()+"----"+s2.getAge());
		s2.show();
	}
}

static关键字：

针对多个对象有共同的成员变量的时候，Java提供了一个关键字static来修饰

/*
	static关键字：
		可以修饰成员变量和成员方法
	特点：
		1.随着类的加载而加载
			main方法
		2.优先于对象存在
		3.被类的所有对象共享
		4.可以通过类名调用
	注意事项
		1.在静态方法中，没有this关键字。
		2.静态方法只能访问静态的成员变量和成员方法。
			静态方法：
				成员变量：只能访问静态变量
				成员方法：只能访问静态成员方法
			非静态方法：
				成员变量：可以是静态的，也可以是非静态的。
				成员方法：可以是静态的成员方法，也可以是非静态的成员方法。
*/
class Student{
	// 非静态变量
	int num = 10;
	
	// 静态变量
	static int num2 = 20;
	
}

class StudentDmeo1{
	public static void main(String[] args){
		Student s = new Student();
		System.out.println(s.num);
		
		// 用类名调用，也可以用对象名调用，推荐使用类名调用。
		System.out.println(Student.num2);
		
	}
}

静态变量和成员变量的区别：

• 所属不同
  • 静态变量属于类，所以也称为类变量
  • 成员变量属于对象，所以也称为实例变量（对象变量）
• 内存中位置不同
  • 静态变量存储于方法区的静态区
  • 成员变量存储于堆内存
• 内存出现时间不同
  • 静态变量随着类的加载而加载，随着类的消失而消失
  • 成员变量随着对象的创建而存在，随着对象的消失而消失
• 调用不同
  • 静态变量可以通过类名调用，也可以通过对象调用
  • 成员变量只能通过对象名调用