Java自学笔记 day07 面向对象

1:成员变量和局部变量的区别(理解)
    (1)在类中的位置不同
        成员变量：类中方法外
        局部变量：方法定义中或者方法声明上
    (2)在内存中的位置不同
        成员变量：在堆中
        局部变量：在栈中
    (3)生命周期不同
        成员变量：随着对象的创建而存在，随着对象的消失而消失
        局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
    (4)初始化值不同
        成员变量：有默认值
        局部变量：没有默认值，必须定义，赋值，然后才能使用
        

class Varialbe {
	//成员变量
	//int num = 10;
	int num; //0
	
	public void show() {
		//int num2 = 20; //局部变量
		//可能尚未初始化变量num2
		//int num2; //没有默认值
		int num2 = 20;
		System.out.println(num2);
		
		//int num = 100;
		System.out.println(num);
	}
}


class VariableDemo {
	public static void main(String[] args) {
		Varialbe v = new Varialbe();
		
		System.out.println(v.num); //访问成员变量
		
		v.show();	
			
	}
}

2:类作为形式参数的问题?(理解)
    (1)如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。

3:匿名对象(理解)
    (1)没有名字的对象
    (2)应用场景
        A:调用方法，仅仅只调用一次的时候。
        b:可以作为实际参数传递。
        

/*
	匿名对象：就是没有名字的对象。
	
	匿名对象的应用场景：
		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();
		s.show();
		System.out.println("--------------");
		
		//匿名对象
		//new Student();
		//匿名对象调用方法
		new Student().show();
		new Student().show(); //这里其实是重新创建了一个新的对象
		System.out.println("--------------");
		
		
		//匿名对象作为实际参数传递
		StudentDemo sd = new StudentDemo();
		//Student ss = new Student();
		//sd.method(ss); //这里的s是一个实际参数
		//匿名对象
		sd.method(new Student());
		
		//在来一个
		new StudentDemo().method(new Student());
 	}
}

4:封装(理解)
    (1)隐藏实现细节，提供公共的访问方式
    (2)好处：
        A:隐藏实现细节，提供公共的访问方式
        B:提高代码的复用性
        C:提高代码的安全性
    (3)设计原则
        把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式
    (4)private是封装的一种体现。
        封装：类，方法，private修饰成员变量

5:private关键字(掌握)
    (1)私有的意义，可以修饰成员变量和成员方法
    (2)特点：
        被private修饰的后的成员只能在本类中被访问
    (3)private的应用：
        以后再写一个类的时候：
            把所有的成员变量给private了
            提供对应的getXxx()/setXxx()方法

6:this关键字(掌握)
    (1)代表当前类的引用对象
        记住：哪个对象调用方法，该方法内部的this就代表那个对象
    (2)this的应用场景：
        A:解决了局部变量隐藏成员变量的问题
        B:其实this还有其他的应用，明天讲解。

7:构造方法(掌握)
    (1)作用：用于对对象的数据进行初始化
    (2)格式：
        A:方法名和类名相同
        B:没有返回值类型，连void都不能有
        C:没有返回值
        

/*
	构造方法：
		给对象的数据进行初始化

	格式：
		A:方法名与类名相同
		B:没有返回值类型，连void都没有
		C:没有具体的返回值
*/
class Student {
	private String name; //null
	private int age; //0
	
	public Student() {
		System.out.println("这是构造方法");
	}
}

class ConstructDemo {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		System.out.println(s); //Student@e5bbd6
	}
}

        思考题：构造方法中可不可以有return语句呢?
        可以。而是我们写成这个样子就OK了：return;
        其实，在任何的void类型的方法的最后你都可以写上：return;
    (3)构造方法的注意事项
        A:如果我们没写构造方法，系统将提供一个默认的无参构造方法
        B:如果我们给出了构造方法，系统将不再提供默认构造方法
            如果这个时候，我们要使用无参构造方法，就必须自己给出。
            推荐：永远手动自己给出无参构造方法。
    (4)给成员变量赋值的方式
        A:setXxx()
        B:带参构造方法
    (5)标准案例
        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;
            }
        }
        
        测试：
        class StudentDemo {
            public static void main(String[] args) {
                //方式1
                Student s1 = new Student();
                s1.setName("科比");
                s1.setAge(27);
                System.out.println(s1.getName()+"---"+s1.getAge());
                
                //方式2
                Student s2 = new Student("科比",30);
                System.out.println(s2.getName()+"---"+s2.getAge());
            }
        }
        

/*
	标准的手机类练习
	
	手机类：
		成员变量：brand,price,color
		构造方法：无参构造
		成员方法：getXxx()/setXxx()
*/
//定义手机类
class Phone {
	//品牌
	private String brand;
	//价格
	private int price;
	//颜色
	private String color;
	
	//无参构造方法
	public Phone() {}
	
	//getXxx()和setXxx()方法
	public String getBrand() {
		return brand;
	}
	
	public void setBrand(String brand) {
		this.brand = brand;
	}
	
	public int getPrice() {
		return price;
	}
	
	public void setPrice(int price) {
		this.price = price;
	}
	
	public String getColor() {
		return color;
	}
	
	public void setColor(String color) {
		this.color = color;
	} 
}

//手机测试类
class PhoneTest {
	public static void main(String[] args) {
		//创建对象
		Phone p = new Phone();
		
		//给成员变量赋值
		p.setBrand("诺基亚");
		p.setPrice(199);
		p.setColor("土豪金");
		
		//获取值
		System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+p.getColor());
	}
}

8:代码：Student s = new Student();做了哪些事情?(理解)
    (1)把Student.class文件加载到内存
    (2)在栈内存为s开辟空间
    (3)在堆内存为学生对象申请空间
    (4)给学生的成员变量进行默认初始化。null,0
    (5)给学生的成员变量进行显示初始化。林青霞,27
    (6)通过构造方法给成员变量进行初始化。刘意,30
    (7)对象构造完毕，把地址赋值给s变量

    
10:static关键字(理解)
    (1)静态的意思。可以修饰成员变量和成员方法。
    (2)静态的特点：
        A:随着类的加载而加载
        B:优先与对象存在
        C:被类的所有对象共享
            这其实也是我们判断该不该使用静态的依据。
            举例：饮水机和水杯的问题思考
        D:可以通过类名调用
            既可以通过对象名调用，也可以通过类名调用，建议通过类名调用。
    (3)静态的内存图
        静态的内容在方法区的静态区
    (4)静态的注意事项；
        A:在静态方法中没有this对象
        B:静态只能访问静态(代码测试过)
    (5)静态变量和成员变量的区别
        A:所属不同
            静态变量：属于类，类变量
            成员变量：属于对象，对象变量，实例变量
        B:内存位置不同
            静态变量：方法区的静态区
            成员变量：堆内存
        C:生命周期不同
            静态变量：静态变量是随着类的加载而加载，随着类的消失而消失
            成员变量：成员变量是随着对象的创建而存在，随着对象的消失而消失
        D:调用不同
            静态变量：可以通过对象名调用，也可以通过类名调用
            成员变量：只能通过对象名调用
    (6)main方法是静态的
        public:权限最大
        static:不用创建对象调用
        void:返回值给jvm没有意义
        main:就是一个常见的名称。
        String[] args:可以接收数据，提供程序的灵活性
            格式：java MainDemo hello world java
                  java MainDemo 10 20 30

/*
	main方法的格式讲解：
		public static void main(String[] args) {...}
		
		public:公共的，访问权限是最大的。由于main方法是被jvm调用，所以权限要够大。
		static:静态的，不需要创建对象，通过类名就可以。方便jvm的调用。
		void:因为我们曾经说过，方法的返回值是返回给调用者，而main方法是被jvm调用。你返回内容给jvm没有意义。
		main:是一个常见的方法入口。我见过的语言都是以main作为入口。
		String[] args:这是一个字符串数组。值去哪里了?
			这个东西到底有什么用啊?怎么给值啊?
				这个东西早期是为了接收键盘录入的数据的。
				格式是：
					java MainDemo hello world java
*/
class MainDemo {
	public static void main(String[] args) {
		//System.out.println(args); //[Ljava.lang.String;@175078b
		//System.out.println(args.length); //0
		//System.out.println(args[0]); //ArrayIndexOutOfBoundsException
		
		//接收数据后
		System.out.println(args); 
		System.out.println(args.length); 
		//System.out.println(args[0]); 
		for(int x=0; x<args.length; x++) {
			System.out.println(args[x]);
		}
	}
}

/*
	static的特点：(它可以修饰成员变量，还可以修饰成员方法)
		A:随着类的加载而加载
			回想main方法。
		B:优先于对象存在
		C:被类的所有对象共享
			举例：咱们班级的学生应该共用同一个班级编号。
			其实这个特点也是在告诉我们什么时候使用静态?
				如果某个成员变量是被所有对象共享的，那么它就应该定义为静态的。
			举例：
				饮水机(用静态修饰)
				水杯(不能用静态修饰)
		D:可以通过类名调用
			其实它本身也可以通过对象名调用。
			推荐使用类名调用。
			
			静态修饰的内容一般我们称其为：与类相关的，类成员
*/
class Student {
	//非静态变量
	int num = 10;
	
	//静态变量
	static int num2 = 20;
}

class StudentDemo {
	public static void main(String[] args) {
		Student s = new Student();
		System.out.println(s.num);
		
		System.out.println(Student.num2);
		System.out.println(s.num2);
	}
}

/*
	static关键字注意事项
		A:在静态方法中是没有this关键字的
			如何理解呢?
				静态是随着类的加载而加载，this是随着对象的创建而存在。
				静态比对象先存在。
		B:静态方法只能访问静态的成员变量和静态的成员方法
				静态方法：
					成员变量：只能访问静态变量
					成员方法：只能访问静态成员方法
				非静态方法：
					成员变量：可以是静态的，也可以是非静态的
					成员方法：可是是静态的成员方法，也可以是非静态的成员方法。
			简单记：
				静态只能访问静态。
*/
class Teacher {
	public int num = 10;
	public static int num2 = 20;
	
	public void show() {
		System.out.println(num); //隐含的告诉你访问的是成员变量
		System.out.println(this.num); //明确的告诉你访问的是成员变量
		System.out.println(num2);
		
		//function();
		//function2();
	}
	
	public static void method() {
		//无法从静态上下文中引用非静态 变量 num
		//System.out.println(num);
		System.out.println(num2);
		
		//无法从静态上下文中引用非静态 方法 function()
		//function();
		function2();
	}
	
	public void function() {
	
	}
	
	public static void function2() {
	
	}
}

class TeacherDemo {
	public static void main(String[] args) {
		//创建对象
		Teacher t = new Teacher();
		t.show();
		System.out.println("------------");
		t.method();
	}
}