Java学习笔记day08

面向对象三大特征

封装

思想: 将事物包装起来
优点: 
	1.方便使用
	2.保护内部
	3.降低耦合度
封装的体现: 
	变量: 封装着一个值
	数组: 封装着一组数据类型相同的值
	对象: 封装着多个属性的值与可以使用的方法
	类: 封装着属性，方法，构造函数
	java文件: 封装着多个类
	方法: 封装一段代码
	...
包: 
	是什么?
		文件夹
	关键字: package
	命名规则: 
		全小写
		com.公司名称缩写或项目名称.分类名
		注意: .表示下级文件夹
	作用: 存储java文件
导包: 
	为什么要导包: 
		当前java文件中使用别的包下的java文件需要导包
	关键字: import
	注意: 
		1.如果当前使用类有当前包下的，也有其它包下的，而且类名相同，此时不建议导包
		2.导包时*表示所有
	语法:	
		import 包名.类名;
	书写位置:
		类上，包下
		
访问权限修饰符: 
	作用:限定内容的使用范围
	关键字: 
		public	公共的	当前项目中可用
		protected	受保护的	在当前包下或继承关系中可用
		不写	默认的		在当前包下可用
		private		私有的		当前类中使用
	建议: 
		1.使用private修饰属性
		2.提供public修饰的get与set方法，用于对属性值的修改与获取		

继承

生活中: 
	晚辈继承长辈物质与精神
代码中: 
	子类将拥有父类的所有属性与方法，构造函数除外
语法: 
	访问权限修饰符 class 子类名 extends 父类名{
	
	}
优点: 
	1.提高代码开发效率
	2.方便修改
	3.降低耦合度
	
注意: 
	1.需要判断两个类是否有继承关系
	2.一个类只能有一个直接父类(单继承)
	3.一个类没有写出继承，那么默认继承于Object类
	4.子类可以拥有特有的属性与方法
	
如: 
	创建猫，狗，鱼，鸟，蛇
		要求: 都有以下属性，名称，品种，年龄，颜色，性别
		
	public class Animal{
		private String name;
		private String sex;
		private int age;
		private String color;
		private String type;
		
		public Animal(){
		
		}
		
		public Animal(String name, String sex, int age, String color, String type){
			this.name = name;
			this.sex = sex;
			this.age = age;
			this.color = color;
			this.type = type;
		}
		
		public String getName(){
			return name;
		}
		
		public void setName(String name){
			this.name = name;
		}
		
		public String getSex(){
			return sex;
		}
		
		public void setSex(String sex){
			this.sex = sex;
		}
		
		public int getAge(){
			return age;
		}
		
		public void setAge(int age){
			this.age = age;
		}
		
		public String getColor(){
			return color;
		}
		
		public void setColor(String color){
			this.color = color;
		}
		
		public String getType(){
			return type;
		}
		
		public void setType(String type){
			this.type = type;
		}
	}
	
	public class Dog extends Animal{
	
	}
	
	public class Cat extends Animal{
	
	}
	
	public class Fish extends Animal{
	
	}
	
	public class Snake extends Animal{
	
	}
	
	public class Bird extends Animal{
	
	}

super

含义: 谁调用super所在的方法，super就表示谁的父类对象
作用: 
	1.当父类属性名/方法名与子类属性名/方法名相同时，用于区分
		this.属性名/方法名(实参列表); 或属性名/方法名(实参列表)子类的属性或方法
		super.属性名/方法名(实参列表)父类的属性或方法
	2.调用父类的属性或方法(this也可以调用)
	3.调用父类构造函数
		super(实参列表);
		注意: 
			1.子类构造函数的第一行必须调用父类构造函数
			2.如果子类构造函数的第一行没有调用父类构造函数，系统会为其自动添加super()，(系统)会默认帮助我们调用父类无参构造函数
			3如果父类没有无参构造函数，子类构造函数就不能默认调用父类无参构造函数，那么子类构造函数将会报错，此时必须自己手动调用父类别的构造函数
		经验: 如果想创建这个类的对象，建议，不管是否使用无参构造都必须提供

有继承关系时创建情况

例子: 
	class A{
		属性A
		方法A
	}
	class B extends A{
	
	}
	class Test{
		public static void main(String[] args){
			B b = new B();
		}
	}
注意: 子类对象的堆内存中拥有父类的属性与方法还有子类特有的属性与方法

多态

概念: 一个事物拥有多种形态
事的多态: 
	重载
		同一个类中，方法名相同，形参列表不同
	重写
		继承关系中，子类方法与父类方法
		子类方法的访问权限修饰符不能小于(大于等于)父类的
		返回值类型相同
		方法名相同
		形参列表相同
		(方法不同)
		
物的多态: 
	向上转型: 子类对象可以转换为父类对象(自动转换)
	语法: 
		父类名 对象名 = 子类对象;
	注意: 
		1.子类对象转换为父类对象后，该父类对象不能调用子类特有的属性或方法
		2.子类对象转换为父类对象后，该父类对象调用重写的方法，执行的是子类中的方法
		3.子类对象转换为父类对象后，该父类对象调用未重写的父类方法，执行的是子类继承父类的方法
		
	向下转型: 父类对象转换为子类对象(强制类型转换)
	语法: 
		子类名 对象名 = (子类名)父类对象;
	注意: 
		父类对象转换为子类对象，可能会出现ClassCastException(类型转换异常)
instanceof关键字
	作用: 判断该对象是否属于该类
	语法: 
		boolean 变量名 = 对象名 instanceof 类名;
		如果变量值为true，表示该对象是该类的对象，可以进行转换
		如果变量值为false，表示该对象不是该类的对象，不能进行转换

练习

宠物医生给宠物治病，宠物有猫，狗，鱼

宠物医生: 小李
宠物: 
	旺财，黄，公(狗)
	富贵，白，公(狗)
	布丁，白，母(猫)
	金龙，黄，雌(鱼)
	
小李给以上宠物治病，病好后，狗作揖，猫叫喵喵喵，鱼跃龙门

分析
	对象: 
		小李	旺财	富贵	布丁	金龙
	类: 
		宠物医生类
			属性: 姓名
			构造函数
			方法: 治病(动物类的对象)
				治病
				父类对象转换为子类对象
				子类对象调用特有方法
				
		动物类
			属性: 名称，颜色，性别
			构造函数: 无参   全参
			方法: get与set
		
		猫类
			继承动物类
			构造函数: 无参   全参
			方法: 叫
		狗类
			继承动物类
			构造函数: 无参   全参
			方法: 作揖
		鱼类
			继承动物类
			构造函数: 无参   全参
			方法: 跃龙门
		环境类(测试类)
			main
			创建小李
			创建旺财，富贵，布丁，金龙
			小李.治病(旺财);
			小李.治病(富贵);
			小李.治病(布丁);
			小李.治病(金龙);

package Demo02;
//定义动物类
public class Animal {
	private String name;
	private String color;
	private String sex;
	
	public Animal() {
		
	}
	
	public Animal(String name, String color, String sex) {
		this.name = name;
		this.color = color;
		this.sex = sex;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
}



package Demo02;
//定义猫类
public class Cat extends Animal{
	public Cat() {
		super();
	}
	
	public Cat(String name, String color, String sex) {
		super(name, color, sex);
	}
	
	public void call() {
		System.out.println(getName() + "叫喵喵喵");
	}
}



package Demo02;
//定义狗类
public class Dog extends Animal{
	public Dog() {
		super();
	}
	
	public Dog(String name, String color, String sex) {
		super(name, color, sex);
	}
	
	public void makeABow() {
		System.out.println(getName() + "作揖");
	}
}



package Demo02;
//定义鱼类
public class Fish extends Animal{
	public Fish() {
		super();
	}
	
	public Fish(String name, String color, String sex) {
		super(name, color, sex);
	}
	
	public void jump() {
		System.out.println(getName() + "跳龙门");
	}
}



package Demo02;
//定义人类
public class Person {
	private String name;
	
	public Person() {
		
	}
	
	public Person(String name) {
		this.name = name;
	}
	
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public void treat(Animal a) {
		System.out.print(name + "给" + a.getName() + "治病, ");
		if(a instanceof Dog) {
			Dog dog = (Dog) a;
			dog.makeABow();
		}
		else if(a instanceof Cat) {
			Cat cat = (Cat) a;
			cat.call();
		}
		else if(a instanceof Fish) {
			Fish fish = (Fish) a;
			fish.jump();
		}
	}
}



package Demo02;
//定义测试类
public class Test {
	public static void main(String[] args) {
		Person person = new Person("小李");
		Dog dog1 = new Dog("旺财", "黄", "公");
		Dog dog2 = new Dog("富贵", "白", "公");
		Cat cat = new Cat("布丁", "白", "母");
		Fish fish = new Fish("金龙", "黄", "雌");
		
		person.treat(dog1);
		person.treat(dog2);
		person.treat(cat);
		person.treat(fish);
	}
}

运行结果