标签:多层 tst 创建 密度 保护 完全 equals imp this
4.使用封装的好处:
◆便于使用者正确使用系统,防止错误修改属性
◆有助于系统之间的松耦合,提高系统独立性
◆提高软件的可重用性
◆降低了构建大型系统的风险
package com.fengzhuang; /* * * @author yutianbao * @param * @date 2019/3/13 22:04 * @return * @Motto: good good study,day day up */ public class FengZhuang { /*封装:将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过 该类提供的方法来实现对隐藏信息的访问。*/ // 实现封装分三步 //1.修改属性的可见性:将属性私有化 private String name; private int age; private String phoneNo; //2.创建setter/getter方法 //给name赋值 public String getName() { return this.name; } //取name值 public void setName(String name) { this.name = name; } public int getAge() { return this.age; } //3.添加对属性操制作的限制 public void setAge(int age) { if(age>0&&age<=150){ this.age = age; }else{ System.out.println("您输入的年龄错误!"); this.age = 25; } } public String getPhoneNo() { return this.phoneNo; } public void setPhoneNo(String phoneNo) { if(phoneNo.length()==11){ this.phoneNo = phoneNo; }else{ System.out.println("您输入的手机号错误!"); this.phoneNo = "1xx xxxx xxxx" ; } } public void print(){ System.out.println("我的名字是;"+this.getName()+",年龄是:"+this.getAge()+",手机号是:"+this.getPhoneNo()); } }
package com.fengzhuang; /* * * @author yutianbao * @param * @date 2019/3/13 22:08 * @return * @Motto: good good study,day day up */ public class Test { public static void main(String[] args){ //FengZhuang fez = new FengZhuang("蒋辉煌",25,"18975742300"); FengZhuang fez = new FengZhuang(); fez.setName("余与"); fez.setAge(160); fez.setPhoneNo("13632908564"); fez.print(); } }
1、类继承用关键字extends实现,格式为:[访问权限修饰符] class 子类名 extends 父类名{ 子类的类体 }
如果没有extends子句,则表示这个类直接继承Object,因为Java中所有的类都继承Object类。
2、成员变量的继承
子类继承父类中所有可被子类访问的成员变量。继承原则如下:
2.1 能够继承那些声明为public和protected的成员变量。
2.2 能够继承同一包中的那些默认修饰符的成员变量。
2.3 不能继承那些声明为private的成员变量。
2.4 如果子类声明一个与父类成员变量同名的成员变量,则不能继承父类的成员变量。此时子类的成员变量称做隐藏了父类的成员变量。
总之,子类可继承父类的public、protected和默认修饰变量,不能继承private变量。反之,如果父类不允许其子类访问它的某些成员,那么它必须以private方式声明该成员。这一点充分体现了类封装的信息隐蔽原则。
3、成员方法的继承
子类继承成员方法的规则类似于继承成员变量的规则:子类继承父类中所有可被子类访问的成员方法。继承规则如下:
3.1 能够继承那些声明为public和protected的成员方法。
3.2 能够继承同一包中的默认修饰符的成员方法。
3.3 不能继承那些声明为private的成员方法。
3.4 不能继承父类的构造方法。
如果子类方法与父类方法同名,则不能继承。子类方法称为覆盖(或重写)了父类中的那个方法。
总之,子类可继承其父类的public、protected和默认修饰方法,不能继承private方法。子类除了可以继承父类中的变量及方法,还可以增加自己的成员。当一个父类成员不适合该子类时,子类会重新定义它,如果是重新定义的是成员变量就是隐藏父类的变量,如果是成员方法就是覆盖父类的方法。
package com.extend; /** * 宠物类,狗狗和企鹅的父类 */ public class Pet { private String name = "无名氏";// 昵称 private int health = 100;// 健康值 private int love = 20;// 亲密度 /** * 无参构造方法 */ public Pet() { System.out.println("父类无参构造方法"); } /** * 有参构造方法 * @param name 昵称 */ public Pet(String name,int health,int love) { this.name = name; this.health = health; this.love = love; System.out.println("父类有参构造方法"); } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getHealth() { return health; } public void setHealth(int health) { if(health<0||health>100){ System.out.println("健康值应该在0至100之间,默认值为60。"); this.health=60; return; } this.health = health; } public int getLove() { return love; } public void setLove(int love) { if(love<0||love>100){ System.out.println("亲密度应该在0至100之间,默认值为10。"); this.love=10; return; } this.love = love; } /** * 输出宠物信息 */ public void print() { System.out.println("宠物的自白:\n我的名字叫" + this.name + ",我的健康值是" + this.health + ",我和主人的亲密程度是" + this.love + "。"); } //重写Object类的equals()方法 public boolean equals(Object obj){ boolean flag = false; if(obj==this){ //==比较引用地址 flag = true; } if(!(obj instanceof Pet)){ //instanceof 判断类型 flag = false; }else{ Pet pe = (Pet)obj; if(pe.love==this.love&&pe.health==this.health&&pe.love==this.love){ flag = true; } } return flag; } }
package com.extend; /** * 狗狗类,宠物的子类 */ public class Dog extends Pet { private String strain="哈士奇";// 品种 //无参构造方法 public Dog(String name,int health,int love,String strain) { super(name,health,love); this.strain = strain; System.out.println("dog类构造方法"); } public String getStrain() { return strain; } public void setStrain(String strain) { this.strain = strain; } //重写父类方法 public void print() { System.out.println("宠物的自白:\n我的名字叫" + this.getName() + ",我的品种是" + this.getStrain()+",我的健康值是" + this.getHealth() + ",我和主人的亲密程度是" + this.getLove() + "。"); } }
package com.extend; import com.sun.jmx.snmp.SnmpString; /** * 企鹅类 */ public class Penguin extends Pet { private String sex="Q仔";// 企鹅性别 //构造方法 public Penguin(String name,int health,int love,String sex) { super(name,health,love); this.sex = sex; System.out.println("penguin类构造方法"); } public String getSex() { return sex; } public void setSex(String sex) { this.sex = sex; } //重写父类方法 public void print() { System.out.println("宠物的自白:\n我的名字叫" + this.getName() + ",我的性别是" + this.getSex()+",我的健康值是" + this.getHealth() + ",我和主人的亲密程度是" + this.getLove() + "。"); } }
package com.extend; //测试类 public class Test { public static void main(String[] args) { // 1、创建宠物对象pet并输出信息 Pet pet = new Pet("贝贝",99,60); //Pet pet1 = new Pet("贝贝",99,60); //Pet pet2 = new Pet("贝贝",99,59); //System.out.println("equals()比较对象:"+pet1.equals(pet2)); pet.print(); // 2、创建狗狗对象dog并输出信息 Dog dog = new Dog("贝贝",59,40,"牧羊犬"); // dog.setName("多多"); // dog.setHealth(90); // dog.setLove(80); // dog.setStrain("吉娃娃"); dog.print(); // 3、创建企鹅对象pgn并输出信息 Penguin pgn = new Penguin("幽幽",85,20,"Q妹"); // pgn.setName("大黑"); // pgn.setHealth(98); // pgn.setLove(99); // pgn.setSex("Q妹"); pgn.print(); /**************************/ // Bus bus = new Bus(20); // bus.print(); //System.out.println(pgn.equals(dog)); } }
4.子类访问父类成员
在数据隐藏和方法覆盖后,子类成员覆盖了父类的同名成员,要访问父类的这些成员,需用super关键字来引用当前类的父类。super的用法有3种情况:
4.1 super.变量名:访问父类中被隐藏的成员变量。
4.2 super.方法名([参数表]):调用父类中被重写的方法。
4.3 super([参数表]):调用父类的构造方法,此时,可用super来表示父类的构造方法。
例子可以参考上面继承的代码
5.继承条件下的构造方法
package com.extend; //测试类 class Car{ private int siteNo = 4;//载客量 public Car(){ System.out.println("载客量是:"+siteNo+"人"); } public void setSiteNo(int siteNo){ this.siteNo = siteNo; } public void print(){ System.out.println("载客量是:"+siteNo+"人"); } } class Bus extends Car{ public Bus(int siteNo){ setSiteNo(siteNo); } } public class Test { public static void main(String[] args) { Bus bus = new Bus(20); bus.print(); } }
5、重写
◆重写是指在继承过程中,子类中的成员(包括数据和方法)与其父类中的成员同名,但功能不同,此时,子类的成员“覆盖”从父类继承过来的成员。包括两种情况:
一是数据覆盖,称为数据隐藏,即父、子类中数据成员的名称相同,类型不同,它们实际上是完全不同的两个数据;
二是方法覆盖,称为方法重写,即父、子类中方法的名称相同,参数表也完全相同,但功能不同。
◆方法重写和方法重载的区别
6.Object类的equals()方法
标签:多层 tst 创建 密度 保护 完全 equals imp this
原文地址:https://www.cnblogs.com/yutianbao/p/10502075.html