Java笔记第八章：面向对象的三大特性[封装、继承、多态]

一、封装

1.目前程序存在的问题：程序没有进行数据安全监测，可能出现业务逻辑问题

2.private：私有的，被private修饰的内容，只能在本类中使用

3.给私有化的属性提供公开的get和set方法

 （1）set方法：为属性赋值
     public void set属性名(数据类型 属性名){
         this.属性名=变量名;
     }
     注意：()中的数据类型取决于赋值对应的属性类型
 （2）set方法：获取属性值
     public 返回值类型 get属性名(){
         return 属性名;
     }
     注意：返回值类型取决于 获取的属性类型

二、继承

 碳素笔 是一种 笔
 水杯  是一种 容器

1.理解

 （1）java中的继承：体现类之间is-a关系
     A  is  a  B关系成立，A和B之间具有继承
     子类      父类
     子类  继承  父类
         extends
 （2）子类通过继承关系，直接使用父类中的属性和方法

2.继承体现了程序的复用性和可扩展性

3.方法的覆盖：[也被称为方法的重写-override]

 （1）理解：子类中定义了和父类中相同的方法
 （2）方法覆盖的要求：
     a.子类中的方法名、形参列表、返回值类型和父类相同
     b.子类的访问修饰符和父类相同，或是比父类更宽
 （3）使用：如果子类覆盖了父类中方法，则优先使用子类覆盖后的方法
 （4）注意事项：
     a.如果子类定义了父类中的方法、形参列表相同，但是返回值类型和父类不同的方法时，编译报错
     b.如果子类定义了和父类方法名、返回值相同，但是参数列表不同的方法时，编译通过，运行也通过，构成了父类+子类中的方法重载
     方法重载：方法名相同，形参列表不同->overload

4.java中的继承特点：

 （1）一个父类可以同时定义多个直接子类
     class Animal{}
     class Cat extends Animal{}
     class Dog extends Animal{}
 （2）一个子类只能有一个直接的父类，但是可以具有多个间接的父类（多级继承），java中的类之间的继承关系是：单继承
     class A{}
     class B extends A{}
     class C extends B{}
     //B是C的直接父类，A是C的间接父类

5.java中的访问修饰符

 （1）访问修饰符代表可以访问的权限
 （2）java中有4个访问修饰符：
     private:私有的
     default:默认的（不用写）
     protected:受保护的
     public:公开的
 （3）访问权限如下：
                   本类    同包    不同包的子类    其他
     private:       ok
     default:       ok     ok
     protected:     ok     ok         ok
     public:        ok     ok         ok         ok
 （4）4个访问修饰符修饰内容的可继承性如下：
     private:被private修饰的属性和方法不允许被继承
     default:被default修饰的属性和方法只能同包子类继承
     protected:...同包+不同包的子类可以继承
     public:...所有子类都可以继承

6.super的应用：

 （1）第一种应用：super
     a.super.:应用在子类的方法中，访问父类中的属性或是成员方法的
     b.super.属性名
       super.成员方法名(实参);
 （2）第二种应用：super()
     a.创建子类对象时，jvm默认创建对应的父类对象，默认使用父类中无参数的构造方法完成父类对象的创建
     b.super()/super(实参):应用在子类构造方法的第一行，代表调用父类构造方法，用于指示剂用哪一个构造方法完成父类对象的创建
     c.子类的构造方法中，如果没有使用super()/super(实参),则在子类的构造方法第一行默认添加super()

三、多态

1.理解：

 （1）父类型的引用存储不同子类的对象
     父类类名 引用名=new 子类类名（）；
       引用            对象
       父类型          子类型
 （2）以父类型的引用调用属性和方法时，只能调用父类中定义的->编译过程检测
 （3）运行过程中，jvm自动检测子类是否覆盖父类中的方法，如果覆盖了，则优先调用子类覆盖后的方法

2.引用之间的转换：

 （1）父类型的引用 赋值给 子类型的引用，需要强制类型转换
         大类型        小类型
     a.如果实际存储的对象类型和转换的类型一致，编译通过，运行通过
     b.如果实际存储的对象类型和转换的类型不一致，编译通过，运行报错，错误信息为：java.lang.ClassCastException(类型转换异常)
 （2）子类型的引用 赋值给 父类型的引用，直接赋值即可
 （3）如果没有继承关系的双方，不允许强制类型转换，编译报错

3.利用instanceof避免类型转换异常

 （1）语法：引用名 instanceof 类名
 （2）应用：判断引用中存储的实际对象类型是否兼容于后面的类型，兼容-true;不兼容-false（兼容，是不是后面的一种）

4.多态的应用场景：

 （1）多态应用在形式参数上：本类型+所有子类型的对象、引用都可以作为实际参数进行传递
 （2）多态应用在返回值上：本类型+所有子类型的对象、引用都可以作为返回值进行返回

package demo;
public class TestAnimal10{
	public static void main(String[] args){
		Animal[] a=new Animal[5];
		a[0]=new Dog();
		a[1]=new Cat();
		a[2]=new Duck();
		a[3]=new Dog();
		a[4]=new Cat();
		for(int i=0;i<a.length;i++){
			a[i].eat();
		}
		int count = 0;
		for(int i=0;i<a.length;i++){
			if(a[i] instanceof Dog){
				count++;
			}
		}
		System.out.println("狗的个数："+count);
		//总和
		int he = 0;
		for(int i=0;i<a.length;i++){
			if(a[i] instanceof Dog||a[i] instanceof Cat){
				he++;
			}
		}
		System.out.println("猫和狗的个数总和："+he);
	}
}
class Animal{
	public void eat(){
		System.out.println("Animal..eat..");
	}
	public void sleep(){
		System.out.println("Animal...sleep...");
	}
}
class Dog extends Animal{
	public void eat(){
		System.out.println("Dog...eat...");
	}
	public void shout(){
		System.out.println("汪汪...");
	}
}
class Cat extends Animal{
	public void eat(){
		System.out.println("Cat...eat...");
	}
}
class Duck extends Animal{
	public void eat(){
		System.out.println("鸭子吃细糠..");
	}
}