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