JAVA学习记录day07

##面向对象
1—面向对象是一种思想.相对面向过程而言的,相对简单.
2–,万物皆对象
3–,面向对象的特征:
–封装性，把相关的数据封装成一个“类”组件
–继承性，是子类自动共享父类属性和方法，这是类之间的一种关系
–多态，增强软件的灵活性和重用性
类和对象的创建和使用

	//测试 类和对象
	//一个.java文件中,可以包含多个类.只不过,只能有一个类,被public修饰.
	//而且,被public修饰的类名就是.java文件名.
	public class Test6_Class {
		public static void main(String[] args) {
			//根据汽车类这个模板,创建一个汽车对象来干活
			//使用new关键字,创建对象
	//		new Car();//匿名对象
			Car c = new Car();//对象的名字叫BMW
			//使用模板里的方法
			c.run();
			c.back();
			//设置c对象的信息
			c.price = 10.9 ;
			c.peizhi = '高' ;
			c.color = "black";
			c.model = "X6";
			//使用模板里的属性/变量
			System.out.println( c.price );//0.0
			System.out.println( c.peizhi );//\u0000
			System.out.println( c.color );//null
			System.out.println( c.model );//null
		}
	}
	//使用class关键字创建汽车类 ,用来描述汽车事物
	class Car{
		//描述事物的特征 -- 成员属性/实例变量/成员变量(在类里方法外)
		//型号,颜色,价格,配置
		double price ;//小数类型的默认值是0.0
		String color ;//引用类型的默认值是null
		String model ;
		char peizhi ;//char类型的默认值是\u0000
		
		//描述事物的功能 -- 成员方法/成员函数
		//前进  后退
		public void run() {
			System.out.println("run()...");
		}
		public void back() {
			System.out.println("back()...");
		}
	}
	
--2,分析手机事物：
	-- 属性：颜色，尺寸，品牌，价格。。。
	-- 行为：打电话，发短信，听音乐。。。。
	-- 测试：
		//练习手机类
		public class Test1_Class {
			public static void main(String[] args) {
				//TODO 创建手机对象测试
				//new Phone().call();//匿名对象--只干一件事情
				Phone p = new Phone() ;
				//调用模板里的方法
				p.call();
				p.music();
				p.message();
				//设置p对象的具体信息
				p.color = "red" ;
				p.size = 5.7 ;
				p.pinpai = "HUAWEI" ;
				p.price = 5999.9 ;
				//调用模板里的属性
				System.out.println(  p.color  );//null
				System.out.println(  p.size  );//0.0
				System.out.println(  p.pinpai  );//null
				System.out.println(  p.price  );//0.0
			}
		}

–3,创建多个对象测试

		//练习手机类
		public class Test1_Class {
			public static void main(String[] args) {
				//创建手机对象测试
				new Phone().call();//匿名对象--只干一件事情
				new Phone().music();//匿名对象--只干一件事情
				
				Phone p = new Phone() ;
				//调用模板里的方法
				p.call();
				p.music();
				p.message();
				//设置p对象的具体信息
				p.color = "red" ;
				p.size = 5.7 ;
				p.pinpai = "HUAWEI" ;
				p.price = 5999.9 ;
				//调用模板里的属性
				System.out.println(  p.color  );
				System.out.println(  p.size  );
				System.out.println(  p.pinpai  );
				System.out.println(  p.price  );
				//TODO 创建p2 p3对象测试
				Phone p2 = new Phone() ;
				//调用模板里的方法
				p2.call();
				p2.music();
				p2.message();
				//设置p对象的具体信息
				p2.color = "white" ;
				p2.size = 6.3 ;
				p2.pinpai = "VIVO" ;
				p2.price = 3999.9 ;
				//调用模板里的属性
				System.out.println(  p2.color  );
				System.out.println(  p2.size  );
				System.out.println(  p2.pinpai  );
				System.out.println(  p2.price  );

				Phone p3 = p2 ;
				System.out.println(  p3.color  );
				System.out.println(  p3.size  );
				System.out.println(  p3.pinpai  );
				System.out.println(  p3.price  );
			}
		}

##封装
–1,通过private关键字实现封装,来提高程序的安全性.可以封装成员变量,也可以封装成员方法.被private修饰后,只能在本类中可见.
–2,练习1:封装学生类

	//测试封装
	public class Test2_Private {
		public static void main(String[] args) {
			// 创建Student对象测试
			Student s = new Student();
			s.coding();
			//s.chiji();//2,因为chiji()已经被封装了,外界无法使用!!
			//设置属性的值
	//		s.name="jack";//4,因为name已经被封装了,外界无法使用!!
	//		s.age=20 ;
			s.setName("jack");
			s.setAge(20);
			//获取属性的值
	//		System.out.println( s.name );//4,因为name已经被封装了,外界无法使用!!
	//		System.out.println( s.age );//0
			System.out.println( s.getName() );//jack
			System.out.println( s.getAge() );
	//		System.out.println( s.score );//0.0
		}
	}
	// 提供Student类
	class Student{
		//特征
		private String name ;
		//5,当属性被private后,外界就没法直接获取或者设置了!!--提供公共的访问方式
		//提供公共的设置方式 setXxx()
		public void setName(String n){
			//拿到你提供的n的值,给name属性赋值
			name = n ;
		}
		//提供公共的获取方式 getXxx()
		public String getName(){
			return name;//把name属性的值,返回给外界的调用位置
		}
		//TODO  封装
		private int age ;
		public void setAge(int a) {
			age = a;
		}
		public int getAge(){
			return age ;
		}
	//自动-右键-source-generate getters and setters-select all-ok
		private double score ;
		public double getScore() {
			return score;
		}
		public void setScore(double score) {
			this.score = score;
		}
		//TODO 封装
		private String addr ;
		private long id ;
		public String getAddr() {
			return addr;
		}
		public void setAddr(String addr) {
			this.addr = addr;
		}
		public long getId() {
			return id;
		}
		public void setId(long id) {
			this.id = id;
		}
		//行为
		public void coding() {
			//3,  在类里, 提供间接的访问方式
			chiji();
			System.out.println("coding()...");
		}
		//1,通过private关键字,实现封装.只能在本类中访问
		private void chiji() {
			System.out.println("chiji()...");
		}
	}

构造方法
–1,用来创建对象 或者 完成对象的初始化.
–2,构造方法可以重载(方法名相同,参数列表不同)
–语法: 修饰符 类名([参数列表]) { 方法体 }
–3,练习1：构造方法创建对象

	//测试 构造方法
	//总结
	//1, 构造方法的语法: 修饰符 类名(参数列表){}
	//2, 构造方法的触发时间节点: 创建对象/new/实例化
	//3, 构造方法可以重载,目的是为了,方便外界比较灵活的创建对象
	public class Test3_Constructor {
		public static void main(String[] args) {
			//1,创建Teacher对象 
			Teacher t = new Teacher();//触发无参构造方法
			//4,创建Teacher对象 -- 触发含参构造方法
			Teacher t2 = new Teacher("李铁蛋");//触发String类型的含参构造
			Teacher t3 = new Teacher(39);//触发int类型的含参构造
			Teacher t4 = new Teacher("李铁蛋",39);//触发String和int的含参构造
		}
	}
	//提供Teacher类
	//构造方法语法:  修饰符 类名([参数列表]){ 方法体 }
	class Teacher{
		//2, 无参构造方法  默认就存在 ---前提是:不要只提供含参构造,否则就真没了!!
		public Teacher() {
			System.out.println(123);
		}
		//3, 含参构造方法 的重载 -- 方法名相同但是参数列表不同!!
		public Teacher(String name) {
			System.out.println("老师叫:"+name);
		}
		//重载的构造方法
		public Teacher(int age) {
			System.out.println("老师"+age+"岁.");
		}
		//TODO 重载的构造方法
		public Teacher(String name,int age){
			System.out.println("老师叫:"+name+",今年:"+age+"岁.");
		}
	}

--4,练习2：构造方法赋值
	//测试 构造方法
	//总结
	//1, 构造方法的语法: 修饰符 类名(参数列表){}
	//2, 构造方法的触发时间节点: 创建对象/new/实例化
	//3, 构造方法可以重载,目的是为了,方便外界比较灵活的创建对象
	public class Test3_Constructor {
		public static void main(String[] args) {
			//1,创建Teacher对象 
			Teacher t = new Teacher();//触发无参构造方法
			//4,创建Teacher对象 -- 触发含参构造方法
			Teacher t2 = new Teacher("王二狗");//触发String类型的含参构造
			Teacher t3 = new Teacher(39);//触发int类型的含参构造
			Teacher t4 = new Teacher("王二狗",39);//触发String和int的含参构造
		}
	}
	//提供Teacher类
	//构造方法语法:  修饰符 类名([参数列表]){ 方法体 }
	class Teacher{
		String name ;
		//2, 无参构造方法  默认就存在 ---前提是:不要只提供含参构造,否则就真没了!!
		public Teacher() {
			System.out.println(123);
		}
		//3, 含参构造方法 的重载 -- 方法名相同但是参数列表不同!!
		public Teacher(String n) {
			name = n ; // ----------!!!构造方法还可以给成员变量赋值!!!---------
			System.out.println("老师叫:"+n);
		}
		//重载的构造方法
		public Teacher(int age) {
			System.out.println("老师"+age+"岁.");
		}
		//重载的构造方法
		public Teacher(String name,int age){
			System.out.println("老师叫:"+name+",今年:"+age+"岁.");
		}
	}