面向对象的三大特性之封装(private)--初步认识及案例实践

面向对象

面向对象概念

面向对象的思想特点:
		1)更符合生活中的思想行为习惯
		2)让我们从执行者变成指挥者
		3)让复杂的事情简单化
面向对象的设计原则:
	不断地创建对象,使用对象,指挥对象做事情
面向对象的三大特征
        1)封装
        2)继承
        3)多态(具体类多态,抽象类多态,借口多态)

面向对象的应用

//测试类
class Test{
	public static void main(String[] args){
        //创建对象phone
		Phone phone = new Phone();	
		phone.brand = "荣耀30pro";
		phone.price = 3999;
		phone.col = "钛空银";
		phone.memory = "8G+256G";
		System.out.println("品牌: "+phone.brand);
		System.out.println("价格: "+phone.price);
		System.out.println("颜色: "+phone.col);
		System.out.println("内存: "+phone.memory);
		phone.callUp("畅聊");
		phone.sendShortMessages();
		phone.playGame("王者荣耀");
	}
}
//定义一个类 phone
class Phone{
	String brand;
	int price;
	String col;
	String memory;
	public void callUp(String chat){
		System.out.println("手机不仅可以打电话!!!还可以"+chat);
	}
	public void sendShortMessages(){
		System.out.println("手机可以发短信!!!");
	}
	public void playGame(String name){
		System.out.println("手机可以"+name+"!!!!");
	}
}

局部变量和成员变量有什么区别

成员变量和局部变量的区别?
		1)书写位置不同
			成员变量:在类中,方法外定义的变量!
			局部变量:在方法声明上或者是方法定义中!
		2)内存中的位置不同
			成员变量:在堆内存中
			局部变量:在栈内存中
		3)生命周期不同:
			局部变量:随着方法调用而存在,随着方法调用完毕而消失!
			成员变量:随着对象的创建完毕而存在,随着对象被GC回收掉而消失
		4)初始化不同:
			成员变量:可以不进行初始化,因为它在堆内存中(跟对象有关系),存在系统默认初始化
			局部变量:必须在使用之前对象局部变量进行初始化

当方法的形式参数为引用类型时

/*方法的形式参数是基本类型:
		形参的改变对实际参数没有影响(是什么类型,传递对应的数据值即可!)
方法的形式参数为引用类型:
		形式参数的改变:会直接影响实际参数!
*/
//定义一个学生类
class Student{
	//定义一个成员方法
	public void study(){
		System.out.println("Good Good Study,Day Day Up!!") ;
	}
}
//定义一个StudentDemo类
class StudentDemo{
	
	//定义一个method成员方法
	public void method(Student s){//形式参数是一个引用类型   
		//实际参数传递的时候:需要改学生类的具体对象 Student student = new Student() ;
		s.study() ; //分析:变量名.成员方法() ;前面这个变量代表当前学生类的对象
	}
}
//测试类
class ArgsDemo2{
	public static void main(String[] args){
		//需求:需要访问StudentDemo类中的method方法
		//1)创建StudentDemo类的对象
		StudentDemo sd = new StudentDemo() ;
		
		//创建一个具体的学生对象
		//student:实际参数
		Student student   = new Student() ;
		sd.method(student) ;
	}
}

匿名对象

/*	匿名对象:
			概念:没有名字的对象!
			匿名对象的创建格式:
					new 类名() ;	
			特点:
				1)可以作为形式参数传递!
				2)匿名对象不要使用多次,使用一次即可!
					匿名对象创建完毕,使用完毕就立即被回收(节省内存空间)				
*/
class Student{
	public void study(){
		System.out.println("我爱学java");
	}

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

}
//测试类
//需求:需要访问StudentDemo类中的show方法
class StudentTest{
	public static void main(String[] args){
		//创建StudentDemo类的对象
		StudentDemo stu = new StudentDemo();
		//创建Student类的对象
		Student student = new Student();
		stu.show(student);
		System.out.println("----------------------") ;
		System.out.println("----------------------") ;
		//使用匿名对象
		StudentDemo stu2 = new StudentDemo();
		stu2.show(new Student());
		System.out.println("----------------------") ;
		System.out.println("----------------------") ;
		//链式编程
		new StudentDemo().show(new Student());
	}

}

封装

/*	封装的概念:
		将一个类的成员变量私有化,外界不能够直接方案,可以通过一些公共的方法(set/get...)间接的访问!
		
	private关键字:
		private:私有的,外界不能访问的!只能在本类中访问
					(但是可以间接通过公共的成员方法来访问私有成员变量/成员方法)
		
		它可以修饰成员变量,也可以修饰成员方法
*/
class Student{
	//属性私有化
	private String name;
	private int age;
	private String gender;
	
	//公共访问方法
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int  getAge(){
		return age;
	}
	public void setGender(String gender){
		this.gender = gender;
	}
	public String getGender(){
		return gender;
	}
	
	
	
	private void playGame(String gameName){
		System.out.println("想玩"+gameName);
	}
	public void want(String game){
		playGame(game);
	}

}
class StudentTest{
	public static void main(String[] args){
		Student s = new Student();
		s.setName("张三");
		s.setAge(20);
		
		s.setGender("女");
		System.out.println(s.getName()+","+s.getAge()+","+s.getGender());
		System.out.println("\n");
		s.want("明日之后");
		
	}
}

构造方法

/*什么是构造方法?
      1)方法名和类名相同
      2)没有具体的返回值类型
      3)连void都没有
          权限修饰符 方法名和类名相同(){  //无参构造方法
        }
     	构造方法的作用:给对象的成员进行数据初始化的!
*/

//提供一学生类
class Student{
	private String name;
	private int age;
	private String gender;
	private String hairStyle;
	//无参构造方法
	public Student(){
	
	}
	//有参构造方法
	public Student(String name,int age,String gender,String hairStyle){
		this.name = name ;
		this.age = age;
		this.gender = gender;
		this.hairStyle = hairStyle;
	}
	//get/set方法赋值
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return age;
	}
	public void setGender(String gender){
		this.gender = gender;
	}
	public String getGender(){
		return gender;
	}
	public void setHairStyle(String hairStyle){
		this.hairStyle = hairStyle;
	}
	public String getHairStyle(){
		return hairStyle;
	}
	public void study(){
		System.out.println("我爱学java");
	}
	public void playGame(){
		System.out.println("能完整的运行出来,我就去打游戏");
	}
	public void eat(String name){
		System.out.println("正在eating!!!"+name);
	}
	public void smoking(){
		System.out.println("he is smoking....");
	}
	
}

//测试类
class Test5{
	public static void main(String[] args){
		Student student = new Student();
		student.setName("java");
		student.setAge(20);
		student.setGender("男");
		student.setHairStyle("光头");
		System.out.println(student.getName()+", "+student.getAge()+", "+student.getGender()+", "+student.getHairStyle());
		student.study();
		student.playGame();
		student.eat("炸鸡");
		student.smoking();
		
		System.out.println("-------------------------");
		
		Student stu = new Student("张三",50,"男","寸头");
		System.out.println(stu.getName()+", "+stu.getAge()+", "+stu.getGender()+", "+stu.getHairStyle());
		student.study();
		student.playGame();
		student.eat("排骨");
		student.smoking();
		
	}
}

static关键字

/*
	static关键字的注意事项:
		1) 在static关键字中,没有this关键字
		2)访问问题:
			非静态的成员方法,既可以访问静态的变量,也可以访问非静态的变量
							也可以访问静态的方法以及非静态的成员方法
			静态的方法只能访问静态的变量/方法

*/
/*static关键字的特点:
		1)被static修饰的成员,随着类的加载而加载 (类就加载一次!)
		  javac xxx.java---->xxx.class  (字节码文件)
		  java xxx ---->运行---->加载类的时候,对象还没开始创建
		2)优先于对象存在 
				对象的创建是在类加载的后面	
		3)有被共享,共用的意思
			这句话:告诉我们什么时候使用static修饰变量,方法
				能够描述被共用,共享的时候
		4)最重要的特点:
			被static修饰的变量以及方法可以被类名直接访问!(推荐类名直接访问)	
			这些被static修饰变量/方法,也可以通过对象名来访问(不推荐!)
*/
class Student{
	public int num = 10;
	public static int num2 = 20;
	
	//成员方法
	public void show(){
		System.out.println("非静态的方法show()");
		System.out.println(num);
		System.out.println(num2);
	}
	public static void method(){
		System.out.println("静态的方法method()");
		System.out.println(num2);
	}
	
}

class StudentTest{
	public static void main(String[] args){
		Student s = new Student();
		s.show();
		Student.method();


	}


}

/*
	需求:
		描述人事物
			属性:姓名,年龄,国籍
			成员方法:提供一个show()方法,作用,输出人的姓名,年龄,国籍
			
			
	按照上面的需求:创建四个人---->国籍都是"中国",从内存角度考虑,
	
		成员变量随着对象的完毕存在----堆内存中 (比较消耗内存空间)
		
		如何改进: Java提供一个关键字:static(共享,共用)
*/

class Person{
//提供三个属性 (默认的修饰符)
	String name;
	int age;
	static String country;
	
	//提供一个无参的构造方法
	public Person(){}
	//提供两个参数的有参构造
	public Person(String name,int age){
		this.name = name;
		this.age = age;
	}
		//提供三个参数的有参构造
	public Person(String name,int age,String country){
		this.name = name;
		this.age = age;
		this.country = country;
	}
	//提供一个成员方法show
	public void show(){
		System.out.println("姓名:"+name);
		System.out.println("年龄:"+age);
		System.out.println("国籍:"+country);
	}
}

class PersonTest{
	public static void main(String[] args){
		Person p1 = new Person("王昭君",20,"中国");
		p1.show();
		System.out.println("--------------------");
		//Person p2 = new Person("西施",21,"中国");
		Person p2 = new Person("西施",21);
		p2.show();
		System.out.println("--------------------");
		//Person p3 = new Person("杨玉环",22,"中国");
		Person p3 = new Person("杨玉环",22);
		p3.show();
		System.out.println("--------------------");
		//Person p4 = new Person("貂蝉",23,"中国");
		Person p4 = new Person("貂蝉",23);
		p4.show();
	
	}

}