Java面向对象(封装,继承,多态)

面向对象

​面向对象: 面向对象是相对于面向过程而言的,面向过程注重的是整个事件的流程,而面向对象注重的是整个过程的对象(事物).

​面向对象的好处:
1.更符合现实生活的逻辑
2.代码更加灵活
3.提高代码的复用率

面向对象的三大特征: 封装 继承 多态

封装

​概念:为了保证数据的安全,信息的隐私,将内部属性设置为私有的,并为其提供可访问的方法(get和set方法),提供给其他类访问

​get方法: 用于获取属性值,所以这个get方法没有参数,设置返回值.

​set方法: 用于设置属性值,所以set方法需要参数,不需要返回值.

为什么需要封装

保护内容的隐私,保护数据的安全

public class Student {
	//封装
	//1.属性私有化
	private int id;
	private String name;
	private int age;
	private String sex;
	private String grade;
	private String address;
	private String phone;
	private String email;
	//2.为其提供get和set访问方法
	public int getId() {
		return id;
	}
	
	public void setId(int id) {
		//this表示本类,创建对象后表示为本对象
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		//保证数据的安全,对数据进行过滤
		if(age<0 || age>140) {
			System.out.println("您输入的年龄不对,默认设置为18");
			age = 18;
		}
		this.age = age;
	}
}

set设置属性过程

get访问过程

对象获取属性的过程

public class StudentDemo {

	public static void main(String[] args) {
		Student stu = new Student();
		//为stu属性赋值
		stu.setId(1001);
		stu.setName("张三");
		stu.setSex("男");
		stu.setAge(22);
		stu.setGrade("大三");
		stu.setAddress("广东广州");
		
		System.out.println("学生ID为:"+stu.getId()+", 姓名:"+stu.getName()+", 籍贯:"+stu.getAddress());
	}

}

this关键字

​this修饰的变量用于指代成员变量.主要作用是(区分局部变量和成员变量重名的问题)

方法的形参如果与成员变量同名,不带this修饰的变量指的是形参变量,而不是成员变量

方法的形参没有与成员变量同名,就算不带this修饰的变量指的是成员变量

构造方法

​构造方法是一种特殊的方法,用于初始化类为对象

​这种方法特征:

1.方法名与类名相同

2.方法没有返回值类型(void都没有)

​3.不能使用static ,final,abstract,synchronized等修饰符修饰

1.为什么使用构造方法

​构造方法用于对象的创建;也可以在创建对象的同时,为属性赋值

2.什么是构造方法

​构造方法是一种特殊的方法,该方法方法名与类名相同,没有返回值类型(void都没有),就是构造方法

格式:  访问修饰符  类名(参数){
    带参构造方法,初始化属性;
}

​注意: 当每个类创建的时候,系统会默认的提供一个无参构造方法,一旦手动定义带参构造方法后,系统会取消无参构造方法,需要自己手动定义无参构造方法

public class Person {

	private int id;
	private String name;
	private String sex;
	private int age;
	private String address;
	//构造方法,系统默认提供一个无参构造方法
	public Person() {}
	
	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	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 getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}
}

构造方法的使用

public class PersonDemo {

	public static void main(String[] args) {
		//使用Person类中的无参构造方法创建对象
		Person per = new Person();
		System.out.println("id为:"+per.getId()+", 姓名为:"+per.getName());
	}
}

构造方法可以重载

构造方法的出现:

1.为什么没有设置构造方法,也可以创建对象?

当我们创建一个类的时候,系统为默认的为每个类添加一个默认的构造方法

2.当手动添加带参构造方法,系统会取消默认构造方法

带参构造方法

	//构造方法,系统默认提供一个无参构造方法
	public Person() {}
	//创建一个带参构造方法,系统会取消默认构造方法,所以手动创建一个无参构造方法
	public Person(int id) {
		this.id = id;
	}

构造方法的使用

public class PersonDemo {

	public static void main(String[] args) {
		//使用Person类中的无参构造方法创建对象
		Person per = new Person();
		//带参构造方法的好处,实例化的同时,初始化属性
		Person p1 = new Person(1001);
		
		System.out.println("id为:"+per.getId()+", 姓名为:"+per.getName());
		System.out.println("id为:"+p1.getId()+", 姓名为:"+p1.getName());
	}
}

构造方法重载,为所有属性初始化

	//构造方法,系统默认提供一个无参构造方法
	public Person() {}
	//创建一个带参构造方法,系统会取消默认构造方法,所以手动创建一个无参构造方法
	public Person(int id) {
		this.id = id;
	}
	//一般构造方法不要使用私有的,因为构造方法就是用来创建对象,被其他类使用
	public Person(int id,String name,String sex,int age,String address) {
		this.id = id;
		this.name = name;
		this.sex = sex;
		this.age = age;
		this.address = address;
	}

构造方法使用

public class PersonDemo {

	public static void main(String[] args) {
		//使用Person类中的无参构造方法创建对象
		Person per = new Person();
		//带参构造方法的好处,实例化的同时,初始化属性
		Person p1 = new Person(1001);
		
		Person p2 = new Person(1003, "王五", "男", 28, "广西省北海市");
		
		System.out.println("id为:"+per.getId()+", 姓名为:"+per.getName());
		System.out.println("id为:"+p1.getId()+", 姓名为:"+p1.getName());
		System.out.println("id为:"+p2.getId()+", 姓名为:"+p2.getName()+", 性别:"+p2.getSex()+", 籍贯:"+p2.getAddress());
	}
}

继承

1.为什么使用继承

​为了减少代码的编写,提高代码的复用,常用继承

2.继承的概念

​继承是面向对象的特征之一,将一系列相似类中共有的属性和方法提取出来形成一个新的类,其他的类来继承这个类,这个类是其他类的父类(超类,基类),其他类是这个类的子类(派生类)

3.继承的关键字 extends 子类继承父类的关键字

public class Pet {
	private int id;
	private String name;
	private int health;
	private int love;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getHealth() {
		return health;
	}
	public void setHealth(int health) {
		this.health = health;
	}
	public int getLove() {
		return love;
	}
	public void setLove(int love) {
		this.love = love;
	}
	
	public void print(){
		System.out.println("宠物的独白:我的编号为:"+id+" ,姓名叫:"+name+" ,健康值为:"+health+" ,与主人的亲密度为:"+love);
	}
	
	public void eat(String food){
		
	}
}

//子类继承父类,使用关键字extends
public class Dog extends Pet {

	private String strain; //品种

	public String getStrain() {
		return strain;
	}

	public void setStrain(String strain) {
		this.strain = strain;
	}	
}

public class Penguin extends Pet {

	private String sex;

	public String getSex() {
		return sex;
	}

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

public class Demo {

	public static void main(String[] args) {
		//创建狗仔
		Dog dog = new Dog();
		//都可以获取到pet类中非私有的属性和方法
		dog.setId(1001);
		dog.setName("旺财");
		dog.setHealth(80);
		dog.setLove(60);
		dog.setStrain("拉布拉多犬");
		dog.print();
		
		Penguin pen = new Penguin();
		pen.setId(1002);
		pen.setName("楠楠");
		pen.setHealth(75);
		pen.setLove(60);
		pen.setSex("Q妹");
		pen.print();
	}
}

继承的内容: 子类继承父类的时候,可以继承父类中的非私有的属性和方法,构造方法不能被继承

继承的好处与弊端

继承的好处:

​提高代码的复用率

​提高代码的维护性(如果需要修改方法,修改父类方法即可)

​弊端:

​继承让类与类之间产生了关系,类的耦合性增强,当父类发生变化时,子类实现类也跟着变化,削弱了子类的独立性

多态

一.为什么要使用多态?

​提高代码的灵活性

二. 什么是多态

​同一个类同一方法,在不同的实例中表现出不同的形态(同一方法,在不同的时刻表现出不同形态)

​多态的前提:

​1.需要继承关系

​2.方法的重写

​3.父类引用指向不同的子类对象

​三.多态中的成员访问特点

​–访问成员变量: 编译看父类,运行看父类 ,子类和父类中有相同名称的变量,优先访问父类变量

​–访问成员方法: 编译看父类,运行看子类 ,子类重写父类方法,优先访问子类中的方法

​多态中,父类引用指向子类对象,只能使用子类和父类中共有的属性和方法

public abstract class Animal {
	
	public int age = 20;
	
	public void eat(){
		System.out.println("动物吃饭..");
	}
}

public class Dog extends Animal {

	public int age = 5;
	public int weight = 30;
	
	@Override
	public void eat() {
		System.out.println("狗啃骨头");
	}
	
	public void jieUFO(){
		System.out.println("狗狗接飞碟..");
	}
}

public class AnimalDemo {

	public static void main(String[] args) {
		//父类引用指向子类对象 ,子类类型自动转换为父类类型,这种叫做多态的向上转型
		Animal an = new Dog();
		System.out.println("狗狗的年龄:"+an.age);
		//System.out.println("狗狗的体重:"+an.weight);
		an.eat();
		//an.jieUFO();
		//an 引用指向 Penguin对象
		an = new Penguin();
		System.out.println("企鹅的年龄:"+an.age);
		an.eat();
	}
	
}

​多态的向上转型

​子类对象赋值给父类引用,从子类类型转换为父类类型,这种就叫做多态的向上转型

public class Master {

	private String name;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	//给宠物喂食,直接转换为父类,通过父类统一喂食
	public void feed(Pet pet,String food){
		pet.eat(food);
	}
	//领养宠物
	public Pet getPet(String num){
		Scanner in = new Scanner(System.in);
		Pet pet = null;
		System.out.println("请输入宠物姓名:");
		String name = in.next();
		if(num.equals("1")){
			System.out.println("请输入狗狗的品种:");
			String strain = in.next();
			pet = new Dog(name,80,60,strain);
		}else if(num.equals("2")){
			System.out.println("请输入企鹅的性别:");
			pet = new Penguin(name, 80, 60, in.next());
		}
		return pet;
	}
}

public class PetDemo {

	public static void main(String[] args) {
		Master master = new Master();
		Pet pet = new Dog();
		pet.setId(1001);
		pet.setName("旺财");
		pet.setHealth(85);
		pet.setLove(60);
		//主人开始喂食
		master.feed(pet, "5斤大骨头");
		
		pet = new Penguin();
		pet.setId(1002);
		pet.setName("团团");
		pet.setHealth(80);
		pet.setLove(65);
		//主人开始喂食
		master.feed(pet, "一条大黄鱼");
		System.out.println("===================================");
		/*
		 * 在主人类中添加一个 getPet(编号)获取宠物的方法          
		 * 测试类:   ==========欢迎来到宠物商店============
		 * 					1.狗狗
		 * 					2.企鹅
		 * 		   ================================
		 * 			请选择要领养的宠物编号:
		 * 
		 */
		Scanner in = new Scanner(System.in);
		System.out.println("==========欢迎来到宠物商店============\n"
						+"\t1.狗狗  \n\t2.企鹅\n"
						+"================================\n请选择要领养的宠物编号:");
		String num = in.next();
		Pet pet1 = master.getPet(num); //通过编号获得宠物
		pet1.print();
		System.out.println("请输入喂养的食物:");
		String food = in.next();
		master.feed(pet1,food);
	}
}

多态的向下转型:

​大的数据类型向小的数据类型转换,父类重新还原为子类类型,需要设置转换的目标类型

​父类类型重新还原为子类类型后,可以使用子类中特有的属性和方法

​向下转型的类型匹配关键字: instanceof 匹配对象是否属于指定类型 是就返回true

public abstract class Animal {
	
	public int age = 20;
	
	public void eat(){
		System.out.println("动物吃饭..");
	}
}

public class Dog extends Animal {

	public int age = 5;
	public int weight = 30;
	
	@Override
	public void eat() {
		System.out.println("狗啃骨头");
	}
	
	public void jieUFO(){
		System.out.println("狗狗接飞碟..");
	}
}

public class AnimalDemo {

	public static void main(String[] args) {
		//父类引用指向子类对象 ,子类类型自动转换为父类类型,这种叫做多态的向上转型
		Animal an = new Dog();
		System.out.println("狗狗的年龄:"+an.age);
		//System.out.println("狗狗的体重:"+an.weight);
		an.eat();
		//an.jieUFO();
		an = new Penguin();
		//an的内在对象是否属于Dog类型
		if(an instanceof Dog){
			//多态的向下转型
			Dog dog = (Dog)an;
			System.out.println("狗狗的体重:"+dog.weight);
			dog.jieUFO();
		}else if(an instanceof Penguin){
			Penguin pen = (Penguin)an;
			pen.setSex("Q仔");
			System.out.println("企鹅的性别:"+pen.getSex());
			pen.siwmming();
		}
	}
}