黑马程序员--Java学习日记之面向对象(封装,继承和构造方法)

------- android培训、 java培训、期待与您交流！ ----------

面向对象思想：
    面向过程，以函数为基础，关注的是实现过程；
    面向对象，以对象为基础，关注的是最终结果；

面向对象思想特点
        是一种更符合我们思想习惯的思想
        可以将复杂的事情简单化
        将我们从执行者变成了指挥者
          角色发生了转换

面向对象开发
      就是不断的创建对象，使用对象，指挥对象做事情。
   面向对象设计
      其实就是在管理和维护对象之间的关系。
   面向对象特征
      封装(en  psul tion)
      继承(inherit ne)
      多态(polymorphism)

面向对象(学生类的定义)

         案例演示

                   属性:姓名,年龄,性别

   行为:学习,睡觉

class Test_Student {
	public static void main(String[] args) {
		//创建对象
		Student s = new Student();
		//对象名.变量名
		s.name = "张三";
		s.age = 23;

		System.out.println(s.name + "..." + s.age);
		//使用成员方法
		s.study();
		s.sleep();
	}
}
class Student {
	String name;						//姓名
	int age;							//年龄
	String gender;						//性别

	public void study() {				//定义学习的方法
		System.out.println("学生学习");
	}

	public void sleep() {				//定义睡觉的方法
		System.out.println("学生睡觉");
	}
}

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

 封装概述
     把同一类型的对象的共同的属性和行为放到一个类里面，就是封装的过程。具体实现方式是隐藏对象的属性和实现细节，仅对外提供公共访问方式。

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

privte关键字的概述和特点
 人类赋值年龄的问题
 privte关键字特点
     是一个权限修饰符
     可以修饰成员变量和成员方法
     被其修饰的成员只能在本类中被访问
 案例演示
     封装和privte的应用：
     把成员变量用privte修饰
     提供对应的getXxx()和setXxx()方法
     privte仅仅是封装的一种体现形式,不能说封装就是私有

class Test_Person {
	public static void main(String[] args) {
		Person p1 = new Person();
		p1.name = "张三";			//调用姓名属性并赋值
		//p1.age = -17;				//调用年龄属性并赋值
		//p1.speak();					

		p1.setAge(-17);

		System.out.println(p1.getAge());
	}
}

class Person {
	String name;					
	private int age;				
	
	public void setAge(int a) {		
		if (a > 0 && a < 200) {
			age = a;
		}else {
			System.out.println("错误");
		}
		
	}

	public int getAge() {			
		return age;
	}

	public void speak() {
		System.out.println(name + "..." + age);
	}
}

 this关键字特点
     代表当前对象的引用（代表本来对象的引用/指代） 
     this的本质是一个对象
     在每一个普通方法里，都有一个this，谁调用这个方法，this就指向谁

构造方法的重载及注意事项

 构造方法的重载

     重载方法名相同,与返回值类型无关(构造方法没有返回值),只看参数列表

构造方法注意事项
     如果我们没有给出构造方法，系统将自动提供一个无参构造方法。
     如果我们给出了构造方法，系统将不再提供默认的无参构造方法。
         注意：这个时候，如果我们还想使用无参构造方法，就必须自己给出。建议永远自己给出无参构造方法

 案例演示
     学生类：
         成员变量：
             name，age
         构造方法：
             无参，带两个参
         成员方法：
            getXxx()/setXxx()
             show()：输出该类的所有成员变量值
 给成员变量赋值：
     setXxx()方法
     构造方法
    
 输出成员变量值的方式：
     通过getXxx()分别获取然后拼接
     通过调用show()方法搞定

class Demo4_Student {
	public static void main(String[] args) {
		Student s1 = new Student();					//使用空参构造
		s1.setName("张三");							//设置姓名
		s1.setAge(23);								//设置年龄

		System.out.println("我的姓名是:" + s1.getName() + ",我的年龄是:" + s1.getAge());
		//getXxx()获取属性值,可以打印,也可以赋值给其他的变量,做其他的操作
		Student s2 = new Student("李四",24);
		s2.show();									
	}
}
class Student {
	private String name;							
	private int age;								

	public Student(){}					//空参构造

	public Student(String name,int age) {			//有参构造
		this.name = name;
		this.age = age;
	}

	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 show() {
		System.out.println("我的姓名是:" + name +  ",我的年龄是:" +  age);
	}
}

 继承(extens)
     让类与类之间产生关系,子父类关系 
继承的好处和弊端
 继承的好处
     提高了代码的复用性
     提高了代码的可维护性
     让类与类之间产生了关系，是多态的前提
 继承的弊端
     类的耦合性增强了。
    
     开发的原则：高内聚，低耦合。
     耦合：类与类的关系
     内聚：就是自己完成某件事情的能力

 继承的注意事项
     子类只能继承父类所有非私有的成员(成员方法和成员变量)
     子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。
     不要为了部分功能而去继承
 继承案例演示：
     动物类,猫类,狗类
     定义两个属性(颜色,腿的个数)两个功能(吃饭，睡觉)
 案例演示
     使用继承前
 案例演示

class Test5_Animal {
	public static void main(String[] args) {
		Cat c1 = new Cat("花",4);
		System.out.println(c1.getColor() + "..." + c1.getLeg());
		c1.eat();
		c1.catchMouse();

		Dog d1 = new Dog("黑",2);
		System.out.println(d1.getColor() + "..." + d1.getLeg());
		d1.eat();
		d1.lookHome();
	}
}
/*
* A:猫狗案例分析
* B:案例演示
	* 猫狗案例继承版
	* 属性:毛的颜色,腿的个数
	* 行为:吃饭
	* 猫特有行为:抓老鼠catchMouse
	* 狗特有行为:看家lookHome
*/

class Animal {
	private String color;					//毛的颜色
	private int leg;						//腿的个数

	public Animal(){}

	public Animal(String color,int leg) {
		this.color = color;
		this.leg = leg;
	}

	public void setColor(String color) {	//设置颜色
		this.color = color;
	}

	public String getColor() {				//获取颜色
		return color;
	}

	public void setLeg(int leg) {			//设置腿的个数
		this.leg = leg;
	}

	public int getLeg() {					//获取腿的个数
		return leg;
	}

	public void eat() {						//吃饭
		System.out.println("吃饭");
	}
}

class Cat extends Animal {
	public Cat() {}							//空参构造

	public Cat(String color,int leg) {		//有参构造
		super(color,leg);
	}

	public void eat() {						//吃鱼
		System.out.println("猫吃鱼");
	}

	public void catchMouse() {				//抓老鼠
		System.out.println("抓老鼠");
	}
}

class Dog extends Animal {
	public Dog() {}							//空参构造

	public Dog(String color,int leg) {		//有参构造
		super(color,leg);
	}

	public void eat() {						//吃肉
		System.out.println("狗吃肉");
	}

	public void lookHome() {				//看家
		System.out.println("看家");
	}
}