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

一、封装

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

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

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

(1) set 方法：为属性赋值

  public void set 属性名 ( 数据类型 变量

名 ){

      this. 属性名 = 变量名 ;

  }

  注意 ： () 中的数据类型取决于赋值对应的属性类型

(2) get 方法：获取属性值

  public 返回值类型 get 属性名 (){

      return 属性名 ;

  }

package execute;
public class test1{
	public static void main(String[]args){
		Student s=new Student();
		//s.name="wys";
		s.setName("wys");
		//s.age=735;
		s.setAge(735);
		//s.score=99.5;
		s.setScore(99.5);
		System.out.println(s.getName()+"-"+s.getAge()+"-"+s.getScore());
		
	}
}
class Student{
	//属性
	private String name;
	private int age;
	private double score;
	//构造方法
	public Student(){}
	public Student(String name,int age,double score){
		this.name=name;
		this.age=age;
		this.score=score;
	}
	//为私有化的属性提供get和set方法
	//set方法：为私有化的属性赋值
	public void setAge(int age){
		if(age>=0&&age<=160){//进行数据安全检测
			this.age=age;
		}else{
			System.out.println("年龄数据不合法...");
		}
	}
	//get方法：获取私有化属性的值
	public int getAge(){
		return age;
	}
	public String getName(){
		return name;
	}
	public void setName(String name){
		this.name=name;
	}
	public double getScore(){
		return score;
	}
	public void setScore(double score){
		this.score=score;
	}
	public void study(){
		System.out.println("....."+age);
	}
}

  注意 ：返回值类型取决于 获取的属性类型

二、继承

碳素笔   是一种   笔

水杯   是一种   容器

狗     是一种   动物

A     is-a     B

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

package execute;
public class testAnimal{
	public static void main(String[]args){
		Dog d= new Dog();
		d.name="旺财";
		d.age=2;
		System.out.println(d.name+"-"+d.age);
		d.eat();
		d.sleep();
		d.run();
		d.shout();
	}
}
//父类-动物
class Animal{
	String name;
	int age;
	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("Animal...eat..eat");
	}
	public void run(){
		System.out.println("Dog...run..");
	}
	public void shout(){
		System.out.println("汪汪");
	}
}

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()

package execute;
public class testAnimal3{
	public static void main(String[]args){
		Dog d=new Dog("大黄","白色");
		System.out.println(d.getName()+"-"+d.getColor());
	}
}
//父类-动物
class Animal{
	private String name;
	public Animal(){}
	public Animal(String name){
		this.name=name;
	}
	public String getName(){
		return name;
	}
	public void setName(){
		this.name=name;
	}
}
//子类-狗
class Dog extends Animal{
	private String color;
	public Dog(){}
	public Dog(String name,String color){
		super(name);
		this.color=color;
	}
	public String getColor(){
		return color;
	}
	public void setColor(String color){
		this.color=color;
	}
}

三、多态

1. 理解：

(1) 父类型的引用存储不同子类型的对象

    父类类名 引用名 = new 子类类名 ();

        引用         对象

        父类型       子类型

(2) 以父类型的引用调用属性和方法时，只能调用父类中定义的-> 编译过程检测

(3) 运行过程， jvm 自动检测子类是否覆盖父类中的方法，如果覆盖了，则优先调用子类覆盖后的方法

2. 引用之间的转换：

(1) 父类型的引用 赋值给 子类型的引用，需要强

制类型转换

      大类型         小类型

  a. 如果实际存储的对象类型和转换的类型一致，编译通过，运行通过

  b. 如果实际存储的对象类型和转换的类型不一致，编译通过，运行报错，错误信息为：

java.lang.ClassCastException( 类型转换异常)

(2) 子类型的引用 赋值给 父类型的引用，直接赋值即可

(3) 如果没有继承关系的双方 , 不允许强制类型转换，编译报错

package execute;
public class testAnimal5{
	public static void main(String[]args){
		Animal a=new Dog();
		a.sleep();
		a.eat();
	}
	
}
//父类-动物
class Animal{
	public void eat(){
		System.out.println("Aniaml....eat");
	}
	public void sleep(){
		System.out.println("Aniaml...sleep");
	}
}
//子类-狗
class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃 狗粮...");
	}
	public void shout(){
		System.out.println("汪汪...");
	}
}
class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼...");
	}
}

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

(1) 语法：引用名 instanceof 类名

(2) 应用：判断引用中存储的实际对象类型是否兼容于后面的类型，兼容-true ；不兼容 -false( 兼容，是不是后面的一种)

package execute;
public class testAnimal6{
	public static void main(String[]args){
		Animal a=new Cat();
		System.out.println(a instanceof Animal);
		System.out.println(a instanceof Dog);
		System.out.println(a instanceof Cat);
		if(a instanceof Dog){
			System.out.println("a中储存的是Dog类型，则强转成功..");
			Dog c=(Dog)a;
			c.shout();
		}else{
			System.out.println("a中储存的不是Dog类型，不能转换..");
		}
	}
	
}
//父类-动物
class Animal{
	public void eat(){
		System.out.println("Aniaml...eat..");
	}
	public void sleep(){
		System.out.println("Aniaml...sleep");
	}
}
//子类-狗
class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃 狗粮...");
	}
	public void shout(){
		System.out.println("汪汪...");
	}
}
class Cat extends Animal{
	public void eat(){
		System.out.println("猫吃鱼...");
	}
}

4. 多态的应用场景：

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

(2) 多态应用在返回值上：本类型 + 所有子类型的对象、引用都可以作为返回值进行返回