面向对象三大特征

2.面向对象三大特征

封装
继承
多态

2.1.封装

2.1.1.私有的属性提供公共的访问方法

public class Hero {
	//private:只有自己可以访问
	private String zhiYe;
	private String name;
	private int hp;	
	
	public String getZhiYe() {
		return zhiYe;
	}

	public void setZhiYe(String zhiYe) {
		this.zhiYe = zhiYe;
	}

	public int getHp() {
		return hp;
	}

	public void setHp(int hp) {
		this.hp = hp;
	}

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

public String getName(){
		return name;
	}

2.1.2.调用方法

2.1.3.Set get方法有快捷键 alt+shift+s

public class Book {
	//属性：成员变量  推荐私有
	private String name;
	private String isbn;
	private int year;
	private double price;
	//为私有的成员变量提供公共的方法访问   取值:getXxx  赋值setXxx
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getIsbn() {
		return isbn;
	}
	public void setIsbn(String isbn) {
		this.isbn = isbn;
	}
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		this.year = year;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	

2.1.4.构造方法

public class Student {
	private String name;
	private int age;	
	public  Student(){
		name="";
		System.out.println("Student----默认的构造方法");
	}
	public  Student(String name){
		System.out.println("Student----有一个参数的构造方法");
		this.name=name;
	}
	public  Student(String name,int age){
		System.out.println("Student----有2个参数的构造方法");
		this.name=name;
		this.age=age;
	}```
	```
public static void main(String[] args) {
		Student s1 = new Student();// 隐式调用了默认的构造方法
		// 调用实例方法：对象打点显示调用
		s1.setName("baoyu");
		s1.setAge(15);
		s1.show();
		s1.show();
		Student s2 = new Student("黛玉", 14);// 隐式调用了带两个参数的构造方法
		s2.show();
		s2=new Student("香菱");// 隐式调用了带一个参数的构造方法
		s2.show();
	}

2.1.5.This关键字

this指代当前对象

2.2.继承

2.2.1.继承语法

public class  ziLei  extends  fuLei{

}

2.2.2.示例

public class Animal {
	// 属性
	protected String name;
	protected String type;
	protected int age;

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

public class Dog extends Animal{
	//3个属性从父类中继承过来的
	//改造父类的内容
	public void eat() {
		System.out.println("啃骨头--------");
	}
	//子类独有的内容
	public void kanJia(){
		System.out.println("看家...............");
	}
}

public class Cat extends Animal{
	
	//方法	
	public void eat() {
		System.out.println("吃鱼--------");
	}
	
	public void zhuaShu(){
		System.out.println("抓老鼠----------");
	}
	
}

public static void main(String[] args) {
		Dog d=new Dog();
		d.setName("二哈1");//继承自父类中方法
		d.eat();//改造了父类的方法
		d.kanJia();//子类中独有的方法
		Cat c=new Cat();
		c.setAge(2);//继承自父类中方法
		c.eat();//改造了父类的方法
		c.zhuaShu();//子类中独有的方法
	}

2.2.3.Java中的访问修饰符

2.2.4.方法的重写

2.2.4.1.要求
1、必须有父子类
2、子类的方法必须与父类中的方法相同，只有方法体不同
2.2.4.2.重写的检测注解@override
表示在子类重写父类的方法上面
该注解的作用：检测是否成功形成了重写
2.2.4.3.作用
改造从父类中继承过来的已有的方法。
2.2.4.4.示例

public class People {
	protected String name;
	protected int age;
	
	public void show(){
		System.out.println("姓名是："+name+"年龄是："+age);
	}

public class Student extends People{
//改造父类的方法：方法的重写 override
@Override
public void show(){
System.out.println(“学生的自我介绍：”+name+"–"+age);
}

在这里插入代码片

2.2.5.继承的特点

2.2.6.Super关键字

指代父类的对象

public class People {
	protected String name;
	protected int age;
	
	public void show(){
		System.out.println(name+"=="+age);
	}
	
	public People() {
		System.out.println("people  默认的构造方法");
	}

	public People(String name, int age) {
		System.out.println("people 有2个参数的构造方法");
		this.name = name;
		this.age = age;
	}

public class Student extends People{
	
	private int classNum;
	
	//this：表示当前对象
	//super：当前对象的父类对象
	public Student() {
		super();//调用父类的默认的构造方法--这句代码无论是否编写，都在这里出现；只能放在第一行
		System.out.println("student ----默认的构造方法");
	}

	public Student(String name, int age) {
		super(name, age);//调用父类的带两个参数的构造方法
		System.out.println("student ----有两个参数的构造方法");
		//this.name=name;
		//this.age=age;
	}

2.3.多态

2.3.1.概念

2.3.2.多态的条件

public class People {
	
	public void show(){
		System.out.println("开心-------------");
	}
}

public class Student extends People {

	@Override
	public void show() {
		System.out.println("中大奖----------开心--------------");
	}
	
	public void study(){
		System.out.println("xuexi------------");
	}

public class Teacher extends People {

	@Override
	public void show() {
		System.out.println("学生个个优秀拿offer-------开心-------------");
	}
	
	public void teach(){
		System.out.println("传授知识技能-------------------");
	}

public static void main(String[] args) {
		//1、有父子类：父类：people  子类：Student  Teacher
		//2、子类重写父类的方法：Student  Teacher都重写了父类的show方法，其余都是独有的方法
		//3、父类的引用指向子类的对象
		People p1=new Student();
		//4、父类的引用调用被子类重写过的方法
		p1.show();
		
		p1=new Teacher();
		p1.show();
	}

2.3.3.多态的作用

提高代码的通用性
2.3.3.1.父类做参数
2.3.3.2.父类做返回值

public class Parent {

	protected String name;
	
	public void teach(){
		System.out.println(name+"管教-----------");
	}

	public String getName() {
		return name;
	}

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

public class Father extends Parent {

	@Override
	public void teach() {
		System.out.println(name+"说教------------------");
	}

public class Mother extends Parent {

	@Override
	public void teach() {
		System.out.println(name+"引经据典讲道理....................");
	}

public class JiaoYu {

	/**
	 * 根据星期几获取家长
	 * @param num
	 * @return
	 */
	public Parent getParent(int num){
		if(num<7 && num%2!=0){//  1  3  5 父亲
			Parent p1=new Father();
			p1.setName("父亲");
			return p1;
		}else if(num<7 && num%2==0){
			Parent p1=new Mother();
			p1.setName("母亲");
			return p1;//  2  4  6 母亲
		}
		return null;//星期天没人管
	}
	
	//教育小孩
	
	public void jiaoYu(Parent p){
		p.teach();
	}
}

public class Test1 {
	public static Scanner input=new Scanner(System.in);
	public static void main(String[] args) {
		JiaoYu jy=new JiaoYu();
		System.out.println("今天星期几：");
		int num=input.nextInt();
		Parent p=jy.getParent(num);//根据星期
		if(p==null){
			System.out.println("今天没人管-------");
		}else{
			jy.jiaoYu(p);
		}
	}