面向对象编程03:封装、继承、多态
文章目录
面向对象编程03:封装、继承、多态封装继承object类supersuper注意点:`super` VS `this`:方法重写多态多态的注意事项:instanceof关键字父类与子类之间的类型转换封装
该露的露、该藏的藏 设计程序要追求“高内聚、低耦合”。高内聚就是类的内部数据操作细节由自己完成,不允许外部干涉;低耦合:仅仅暴露少量的方法给外部使用。 封装(数据的隐藏) 通常我们应该禁止直接访问一个对象中数据的实际表示,而应该通过操作接口来访问,这被称为“信息隐藏”。 理解封装,记住这句话就够了:属性私有,get/set下面我们来看看封装的代码实例:
public class Student {//属性私有:privateprivate String name;//名字private int id;//学号private char sex;//性别private int age;//年龄//提供一些可以操作这个属性的方法:public的get、set方法//Alt+Enter快捷创建get和set方法//get 获得这个数据//set 设置值public void setName(String name) {this.name = name;}public String getName() {return this.name;}public int getAge() {return age;}public void setAge(int age) {if (age<0||age>120){System.out.println("invalid number");}else{this.age= age;}}}public class Application {public static void main(String[] args) {Student student = new Student();student.setName("David");//将David通过setName方法赋值给name.System.out.println(student.getName());student.setAge(20);System.out.println(student.getAge());}}输出结果:David20
封装的好处:
提高程序的安全性。保护数据隐藏代码的实现细节统一接口增加了系统的可维护性
继承
继承的本质是对某一批类的抽象,从而实现对现实世界更好的建模。extends的意思是“扩展”。子类是父类的扩展。JAVA中类只有单继承,没有多继承!继承是类与类之间的一种关系。除此之外,类和类之间的关系还有依赖、组合、聚合等。继承关系的两个类:一个为子类(派生类),一个为父类(基类)。子类继承父类,使用关键字extends表示。子类和父类之间从意义上讲应该具有“is a”的关系。下面我们来看一个简单的继承的例子:
//Java中所有的类都默认直接或间接继承object类//父类: Personclass Person /*extends object*/ {int money = 10_000_000;public void say(){System.out.println("说了一句话");}}//子类:Student//继承了父类的所有方法class Student extends Person {}public class Application {public static void main(String[] args) {Student student = new Student();student.say();//say是父类Person的方法System.out.println(student.money);//money是父类Person中的变量}}
object类
在Java中所有的类都默认直接或间接继承object类。
class Person /*extends object*/ {}
java的Object类方法如下:
getClass
方法
获取运行时类型,返回值为Class对象
hashCode
方法
返回该对象的哈希码值,是为了提高哈希表的性能(HashTable)
equals
方法
判断两个对象是否相等,在Object源码中equals就是使用去判断,所以在Object中equals是等价于的,但是在String及某些类对equals进行了重写,实现不同的比较。
clone
方法
主要是JAVA里除了8种基本类型传参数是值传递,其他的类对象传参数都是引用传递,我们有时候不希望在方法里将参数改变,这时就需要在类中复写clone方法。
如果在clone方法中调用super.clone()方法需要实现Cloneable接口,否则会抛出CloneNotSupportedException。
此方法只实现了一个浅层拷贝,对于基本类型字段成功拷贝,但是如果是嵌套对象,只做了赋值,也就是只把地址拷贝了,所以没有成功拷贝,需要自己重写clone方法进行深度拷贝。
5.toString
方法
返回一个String字符串,用于描述当前对象的信息,可以重写返回对自己有用的信息,默认返回的是当前对象的类名+hashCode的16进制数字。
wait
方法
多线程时用到的方法,作用是让当前线程进入等待状态,同时也会让当前线程释放它所持有的锁。直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,当前线程被唤醒
notify
方法
多线程时用到的方法,唤醒该对象等待的某个线程
notifyAll
方法
多线程时用到的方法,唤醒该对象等待的所有线程
9.finalize
对象在被GC释放之前一定会调用finalize方法,对象被释放前最后的挣扎,因为无法确定该方法什么时候被调用,很少使用。
super
super关键字指向父类://父类: Personclass Person {int age = 60;public void say(){System.out.println("Person说了一句话");}}//子类:Student//继承了父类的所有方法class Student extends Person{public void print() {System.out.println("Peosin is"+ super.age);System.out.println("Student");super.say();//}}public class Application {public static void main(String[] args) {Student student = new Student();student.print();}}输出结果:Person is 60StudentPerson说了一句话
调用子类构造器时相当于提前执行了一行隐藏代码:super();
:
//父类: Personclass Person {public Person() {System.out.println("Person无参构造已执行");}}//子类:Student//继承了父类的所有方法class Student extends Person{//super();public Student() {System.out.println("Student无参构造已执行");}}/*** @author 15065170282*/public class Application{public static void main(String[] args) {Student student = new Student();}}输出结果:Person无参构造已执行Student无参构造已执行
super注意点:
super
调用父类的构造方法,必须在构造方法的第一个;super
只能出现在子类的方法或者构造方法中;super
和this
不能同时调用构造方法!super
VSthis
:
二者代表对象不同:
this
: 代表调用者本身
super
: 代表父类应用
使用前提不同:
this
: 不用继承就能直接使用
super
: 只能在继承条件下使用
构造方法:
this();
代表本类的构造
super();
代表父类的构造
方法重写
前提:方法重写需要有继承关系,即子类重写了父类的***方法***,方法名、参数都一致但是方法体不同
方法重写只针对于实例方法,静态方法不存在重写
方法重写只针对于public关键字修饰的方法,private修饰的无法被继承
参数列表必须相同(不同就变成重载了)
修饰符:范围可以扩大但不能缩小: public>protected>default>private
抛出的异常范围可以被缩小但是不能扩大:
为什么需要重写?
因为有时父类的功能子类不一定需要或不一定满足;
快捷键(IDEA中):Alt + Insert
class Person{public void say(){System.out.println("父亲说了一句话");}}class Student extends Person{@Overridepublic void say() {System.out.println("Student 重写了Person的方法");}}/*** @author 15065170282*/public class OverrideTest {public static void main(String[] args) {Person person = new Person();person.say();Student student = new Student();student.say();}}
多态
同一方法可以根据发送对象的不同采取多种不同的行为方式。一个对象的实际类型是确定的,但可以指向该对象的引用类型有很多多态存在的条件: 有继承关系子类重写父类方法父类引用指向子类对象下面来看一个多态的实例:
package JavaSe.oop.demo07;class Person{public void run(){System.out.println("run");}}class Student extends Person{@Overridepublic void run() {System.out.println("子类重写了父类的run方法");}public void eat(){System.out.println("eat");}}/*** @ClassName Application* @author 15065170282**/public class Application {public static void main(String[] args) {//一个对象的实现类是确定的:new Student(); new Person();//但是引用类不能确定:父类的引用指向子类//Student能调用的方法都是自己的或者是继承父类的!Student s1 = new Student();//Person父类可以指向子类但是不能调用子类独有的方法;Person s2=new Student();Object s3=new Student();//对象能执行哪些方法取决于引用类的类型,和实现类无关;s1.eat();((Student) s2).eat();//类型转换s1.run();s2.run();}}输出结果:eateat子类重写了父类的run方法子类重写了父类的run方法
多态的注意事项:
多态指的是方法的多态,属性没有多态一说。
父类和子类因为有联系(继承关系)才能进行转换
类型转换异常:ClassCastException!
存在条件: 继承关系,方法需要重写,父类引用指向子类对象: Father F1 = new Son();
无法重写:
static
方法,属于类,不属于实例;final
常量;private
方法;
instanceof关键字
instanceof 关键字用于判断两个类之间是否有父子关系。
public class InstanceOfTest {public static void main(String[] args) {//System.out.println(X instanceof Y);//能否编译通过取决于X与Y之间是否有关//object-->Person-->Student//object-->Person-->TeacherObject o = new Object();System.out.println(o instanceof Student);System.out.println(o instanceof Person);System.out.println(o instanceof Object);System.out.println(o instanceof Teacher);System.out.println(o instanceof String);System.out.println("====================================");Person person = new Person();System.out.println(person instanceof Student);System.out.println(person instanceof Person);System.out.println(person instanceof Object);System.out.println(person instanceof Teacher);//编译时就会报错:System.out.println(person instanceof String);System.out.println("====================================");Student student = new Student();System.out.println(student instanceof Student);System.out.println(student instanceof Person);System.out.println(student instanceof Object);//编译时就会报错:System.out.println(student instanceof Teacher);//编译时就会报错:System.out.println(student instanceof String);}}输出结果:falsefalsetruefalsefalse====================================falsetruetruefalse====================================truetruetrue
父类与子类之间的类型转换
父类引用指向子类的对象: Father f = new Son();子类转换成父类,向上转型;父类转换成子类,向下转型:强制转换作用:方便方法的调用,减少代码的重复下面来看父子类类型转换的代码实例:
class Test{}class TestSon extends Test{public void go(){System.out.println("go");}}/*** @ClassName Application* @Author ${17368877923}**/public class Application {public static void main(String[] args) {//类型之间的转化: 父 子//高------>低需要强转//低------>高可以直接转Test test = new TestSon();new TestSon().go();//对象.方法//test.go();TestSon testSon = (TestSon) test;//可以对比int testSon=3; double test =3.0; int testSen=(int) test;高到低强转 // testSon将test对象转换为TestSon类型,我们就可以使用TestSon类型的方法了testSon.go();((TestSon) test).go();}}