面向对象的三大特性

三大特性

封装

• 概念：尽可能隐藏对象的内部实现细节，控制对象的修改及访问的权限。
• 访问修饰符：private （可将属性修饰为私有，仅本类可见）
• 以访问方法的形式，进而完成赋值与取值操作。
• 提供公共访问方法，以保证数据的正常录入。
• 命名规范：
  赋值：setXXX() //使用方法参数实现赋值
  取值：getXXX() //使用方法返回值实现取值

public class User {
	String name;
	//私有属性
	private int age;
	private char sex;
	double money;
	
	//对外提供公共的访问方法   setXXX  getXXX
	public void setAge(int age) {
		if(age < 0 || age > 120) {
			System.out.println("年龄不合法");
			//设置默认值
			this.age = 18;
		}else {
			this.age = age;
		}
	}
	public int getAge() {
		return this.age;
	}
	public void setSex(char sex) {
		if(sex != '男' && sex != '女') {
			System.out.println("性别不存在");
			this.sex = '男';
		}else {
			this.sex = sex;
		}
	}
	public char getSex() {
		return this.sex ;
	}
}

JavaBean 设计

类：实体类 JavaBean。
JavaBean 分为两种：1、数据承载Bean 2、业务逻辑Bean
数据承载Bean的要求

• 1、私有化属性
• 2、对外提供公共的set、get方法
• 3、提供有参无参构造

public class Product { 
	private String name;
	private double price;
	private String type;
	private int num;
	//提供构造方法   alt+shift+s   
	public Product(String name, double price, String type, int num) {
		super();
		this.name = name;
		this.price = price;
		this.type = type;
		this.num = num;
	}
	public Product() {
		super();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
}

继承

• 继承概念：类与类之间属性和方法的赠与和获得
• 继承作用：减少代码的冗余，提高代码的复用性。
• 继承语法：子类 extends 父类
  继承的特点
• 1、子类继承父类，可以继承父类中的属性和方法
• 2、子类可以拥有自己独有的属性和方法
• 3、单继承,即在java中一个子类只能继承一个父类。但是一个父类可以拥有多个子类
• 4、多重继承，即一个父类还可以继承另外一个类。java中最大的父类的是Object(如果一个没有显示的写出extends 父类，默认就是Object子类)
  不可继承
• 1、构造方法不能被继承
• 2、父类的私有属性不能被继承
• 3、父类中使用默认的修饰符的修饰的属性和方法在不同包的子类中不能被继承

访问修饰符

访问修饰符

private私有的 default缺省的、默认的、友好的 protected 受保护的 public 公开的

方法重写

方法的重写/覆盖
子类中有与父类相同签名的方法称之为方法重写
重写的特点：

• 相同签名 :方法名相同、参数相同、返回值相同、子类访问修饰符要比父类更宽泛
  重写的作用：
• 因为父类的方法无法满足子类的需求，所以需要重写父类的方法
  注解：@Override 建议在重写方法的时候，加上注解
• 检测是否是满足方法重写。必须满足重写的要求，否则报错
  [注意：不能被继承的方法就不能被重写]

public class Father {	
	public void study(int hour) {
		System.out.println("学习:"+hour+"小时。。");
	}	
}
public class Son extends Father{
    //重写父类的study方法
	@Override
	public void study(int hour) {
		System.out.println("子类学习"+hour/3+"个小时...");
	}
}

super关键字

含义：直接父类的对象
作用：可以调用父类的属性、方法、构造方法

• 调用父类属性和方法的时候：
  • 1、当子类与父类有重名属性和重名方法的时候，this.属性、this.方法名表示调用子类的属性和方法
  • 2、当子类与父类有重名属性和重名方法的时候，super.属性、super.方法名表示调用父类的属性和方法
  • 3、如果没有重名属性和方法，那么this和super表示的都是父类的属性和方法(子类继承而来)
• 调用父类的构造方法的时候：
  • 注意：创建子类对象之前，必须要先创建父类的对象
  • 1、super();调用的是父类的无参构造。是可以完全省略的，省不省略都会执行(建议：保留父类的无参构造)
  • 2、 super调用父类的有参构造，要放到构造方法第一行。super和this不能同时出现

多态

概念：父类引用指向子类对象，从而产生多种形态。

二者具有直接或间接的继承关系时，父类引用可指向子类对象，即形成多态。
父类引用仅可调用父类所声明的属性和方法，不可调用子类独有的属性和方法。
多态的特点

• a、必须要有继承关系
• b、必须要有方法重写
• c、必须要有父类的引用指向子类的对象
  向上转型和向下转型
  如果发生多态要调用子类自己独有的方法和属性，那么需要发生向下转型。
  但是发生向下转型之前必须要发生过向上转型

Pet pet = new Dog(); //向上转型
Dog d = (Dog)pet;	//向下转型

instanceOf关键字
语法： 对象名 instanceof 类型
作用：判断该对象是否属于该类型。属于返回true，否则返回false
应用场景：在向下转型之前，最好先做一个判断。以免发生类型转换异常的错误

ublic class Doctor {
    public void seeADoctor(Pet pet){
        pet.toHealth();
        pet.health=100;
        //判断pet 是不是Dog类
        **if (pet instanceof Dog){
            ((Dog) pet).swim();
        }
        //判断pet 是不是Cat类
        if (pet instanceof Cat){
            ((Cat) pet).catchTheMouse();
        }**
    }
}

多态的应用场景
将参数改为父类类型，使用更加等宽泛和灵活
将返回值类型改为父类类型，更将灵活

public class PetFactory {
    public Pet create(String type){
        if (type.equals("dog")){
            **return new Dog();**
        }
        **return new Cat();**
    }
}