JavaSE：第5章 面向对象编程(中)
文章目录
- JavaSE：第5章 面向对象编程(中)
- 5.1 OOP特征二：继承性
- 5.2 方法的重写(override)
- 5.3 四种访问权限修饰符
- 5.4 关键字：super
- 5.5 子类对象实例化过程
- 5.6 OOP特征三：多态性
- instanceof 操作符
- 对象类型转换 (Casting )
- 5.7 Object类的使用
- 5.7.1 Object类中的主要结构
- 5.7.2 ==操作符与equals方法
- 5.7.3 toString() 方法
- 5.8 包装类的使用
- 5.8.1 总结：基本类型、包装类与String类间的转换
- 5.8.2 包装类用法举例
JavaSE：第5章 面向对象编程(中)
5.1 OOP特征二：继承性
- 为描述和处理个人信息，定义类Person:
- 为描述和处理学生信息，定义类Student:
- 通过继承，简化Student类的定义:
- 为什么要有继承？
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
那么多个类无需再定义这些属性和行为，只要继承那个类即可
此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。可以理解为:“子类 is a 父类”
类继承语法规则:
class Subclass extends SuperClass{ }作用：
1.继承的出现减少了代码冗余，提高了代码的复用性。
2.继承的出现，更有利于功能的扩展。
3.继承的出现让类与类之间产生了关系，提供了多态的前提。
- 注意：不要仅为了获取其他类中某个功能而去继承
- 子类继承了父类，就继承了父类的方法和属性。
- 在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
- 在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。
- Java只支持单继承和多层继承，不允许多重继承
1.一个子类只能有一个父类
2.一个父类可以派生出多个子类①class SubDemo extends Demo{ } //ok
②class SubDemo extends Demo1,Demo2…//erro
5.2 方法的重写(override)
- 定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
- 要求：
- 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
- 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
- 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
子类不能重写父类中声明为private权限的方法
- 子类方法抛出的异常不能大于父类被重写方法的异常
- 注意：
子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。
5.3 四种访问权限修饰符
5.4 关键字：super
在Java类中使用super来调用父类中的指定操作：
super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造器中调用父类的构造器注意：
尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
super的追溯不仅限于直接父类
super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识
- 调用父类的构造器
- 子类中所有的构造器默认都会访问父类中空参数的构造器
- 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能”二选一”，且必须放在构造器的首行
- 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错
5.5 子类对象实例化过程
5.6 OOP特征三：多态性
- 多态性，是面向对象中最重要的概念，在Java中的体现：
- 对象的多态性：父类的引用指向子类的对象
可以直接应用在抽象类和接口上
- 对象的多态性：父类的引用指向子类的对象
- Java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）
“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法） - 对象的多态 —在Java中,子类的对象可以替代父类的对象使用
一个变量只能有一种确定的数据类型
一个引用类型变量可能指向(引用)多种不同类型的对象
Person p = new Student();
Object o = new Person();//Object类型的变量o，指向Person类型的对象
o = new Student(); //Object类型的变量o，指向Student类型的对象
- 子类可看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型(upcasting)。
- 一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法
Student m = new Student();
m.school = “pku”; //合法,Student类有school成员变量
Person e = new Student();
e.school = “pku”; //非法,Person类没有school成员变量
//属性是在编译时确定的，编译时e为Person类型，没有school成员变量，因而编
译错误。
- 虚拟方法调用(Virtual Method Invocation)
正常的方法调用
Person e = new Person(); e.getInfo(); Student e = new Student(); e.getInfo();虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
Person e = new Student();e.getInfo(); //调用Student类的getInfo()方法编译时类型和运行时类型
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类
的getInfo()方法。——动态绑定
- 小结：方法的重载与重写
- 二者的定义细节：略
- 从编译和运行的角度看：
重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不
同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了
不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类
和子类的，即子类可以重载父类的同名不同参数的方法。
所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，
这称为“早绑定”或“静态绑定”；
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体
方法，这称为“晚绑定”或“动态绑定”。
引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”
- 多态小结
- 多态作用：
提高了代码的通用性，常称作接口重用
- 前提：
需要存在继承或者实现关系
有方法的重写 - 成员方法：
编译时：要查看引用变量所声明的类中是否有所调用的方法。
运行时：调用实际new的对象所属的类中的重写方法。 - 成员变量：
不具备多态性，只看引用变量所声明的类。
- 多态作用：
instanceof 操作符
对象类型转换 (Casting )
- 子类继承父类
- 若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
- 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量
5.7 Object类的使用
- Object类是所有Java类的根父类
- 如果在类的声明中未使用extends关键字指明其父类，则默认父类
为java.lang.Object类
public class Person {
…
}
等价于：
public class Person extends Object {
…
} - 例：method(Object obj){…} //可以接收任何类作为其参数
Person o=new Person();
method(o);
5.7.1 Object类中的主要结构
| NO. | 方法名称 | 类型 | 描述 |
|---|---|---|---|
| 1 | public Object() | 构造 | 构造器 |
| 2 | public boolean equals(Object obj) | 普通 | 对象比较 |
| 3 | public int hashCode() | 普通 | 取得Hash码 |
| 4 | public String toString() | 普通 | 对象打印时调用 |
5.7.2 ==操作符与equals方法
= =：
基本类型比较值:只要两个变量的值相等，即为true。
int a=5; if(a==6){…}
引用类型比较引用(是否指向同一个对象)：只有指向同一个对象时，==才返回true。
Person p1=new Person();
Person p2=new Person();
if (p1==p2){…}用“==”进行比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)，否则编译出错
equals()：所有类都继承了Object，也就获得了equals()方法。还可以重写
只能比较引用类型，其作用与“==”相同,比较是否指向同一个对象。
格式:obj1.equals(obj2)特例：当用equals()方法进行比较时，对类File、String、Date及包装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个对象；
原因：在这些类中重写了Object类的equals()方法。
当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等
重写equals()方法的原则
- 对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。
- 自反性：x.equals(x)必须返回是“true”。
- 传递性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。
- 一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。
- 任何情况下，x.equals(null)，永远返回是“false”；
x.equals(和x不同类型的对象)永远返回是“false”。
5.7.3 toString() 方法
- toString()方法在Object类中定义，其返回值是String类型，返回类名和它的引用地址。
- 在进行String与其它类型数据的连接操作时，自动调用toString()方法
Date now=new Date();
System.out.println(“now=”+now); 相当于
System.out.println(“now=”+now.toString()); - 可以根据需要在用户自定义类型中重写toString()方法
如String 类重写了toString()方法，返回字符串的值。
s1=“hello”;
System.out.println(s1);//相当于System.out.println(s1.toString()); - 基本类型数据转换为String类型时，调用了对应包装类的toString()方法
int a=10; System.out.println(“a=”+a);
5.8 包装类的使用
- 针对八种基本数据类型定义相应的引用类型—包装类（封装类）
- 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象
- 基本数据类型包装成包装类的实例 —装箱
通过包装类的构造器实现：
int i = 500; Integer t = new Integer(i);
还可以通过字符串参数构造包装类对象：
Float f = new Float(“4.56”);
Long l = new Long(“asdf”); //NumberFormatException - 获得包装类对象中包装的基本类型变量 —拆箱
调用包装类的.xxxValue()方法：
boolean b = bObj.booleanValue(); - JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。
- 字符串转换成基本数据类型
通过包装类的构造器实现：
int i = new Integer(“12”);
通过包装类的parseXxx(String s)静态方法：
Float f = Float.parseFloat(“12.1”); - 基本数据类型转换成字符串
调用字符串重载的valueOf()方法：
String fstr = String.valueOf(2.34f);
更直接的方式：
String intStr = 5 + “”
5.8.1 总结：基本类型、包装类与String类间的转换
5.8.2 包装类用法举例
int i = 500;
Integer t = new Integer(i);
装箱：包装类使得一个基本数据类型的数据变成了类。
有了类的特点，可以调用类中的方法。
String s = t.toString(); // s = “500“,t是类，有toString方法
String s1 = Integer.toString(314); // s1= “314“ 将数字转换成字符串。
String s2=“4.56”;
double ds=Double.parseDouble(s2); //将字符串转换成数字
- 拆箱：将数字包装类中内容变为基本数据类型。
int j = t.intValue(); // j = 500，intValue取出包装类中的数据 - 包装类在实际开发中用的最多的在于字符串变为基本数据类型。
String str1 = “30” ;
String str2 = “30.3” ;
int x = Integer.parseInt(str1) ; // 将字符串变为int型
float f = Float.parseFloat(str2) ; // 将字符串变为int型
面试题
import org.junit.Test;
public class InterviewTest {@Testpublic void test3() {Integer i = new Integer(1);Integer j = new Integer(1);System.out.println(i == j);//false//Integer 内部定义了IntegerCache结构，IntegerCache中定义了Integer[],//保存了从-128~127范围的整数。如果我们使用自动装箱的方式，给Integer赋值的范围在//-128~127范围内时，可以直接使用数组中的元素，不用再去new了。目的：提高效率Integer m = 1;Integer n = 1;System.out.println(m == n);//tureInteger x = 128; //new了一个IntegerInteger y = 128; //new了一个IntegerSystem.out.println(x == y); //false}
}------------------------------------------------------------
package day7_4;
import java.util.Scanner;
import java.util.Vector;
/** 利用Vector代替数组处理：从键盘读入学生成绩（以负数代表输入结束），找出最高分，并输出学生成绩等级。提示：数组一旦创建，长度就固定不变，所以在创建数组前就需要知道它的长度。而向量类java.util.Vector可以根据需要动态伸缩。创建Vector对象：Vector v=new Vector();给向量添加元素：v.addElement(Object obj); //obj必须是对象取出向量中的元素：Object obj=v.elementAt(0);注意第一个元素的下标是0，返回值是Object类型的。计算向量的长度：v.size();若与最高分相差10分内：A等；20分内：B等；30分内：C等；其它：D等*****/
public class ScoreTest {public static void main(String[] args) {//1.实例化Scanner，用于从键盘获取学生成绩Scanner scan = new Scanner(System.in);//2.创建Vector对象：Vector v=new Vector();相当于原来的数组Vector v = new Vector();//3.通过for(;;)或while(true)方式，给Vector中添加数组int maxScore = 0;for(;;){System.out.println("请输入学生成绩（以负数代表输入结束）");int score = scan.nextInt();//3.2 当输入是负数时，跳出循环if(score < 0){break;}if(score > 100){System.out.println("输入的数据非法，请重新输入");continue;}//3.1 添加操作：：v.addElement(Object obj)//jdk5.0之前：
// Integer inScore = new Integer(score);
// v.addElement(inScore);//多态//jdk5.0之后：v.addElement(score);//自动装箱//4.获取学生成绩的最大值if(maxScore < score){maxScore = score;}}//5.遍历Vector，得到每个学生的成绩，并与最大成绩比较，得到每个学生的等级。char level;for(int i = 0;i < v.size();i++){Object obj = v.elementAt(i);//jdk 5.0之前：
// Integer inScore = (Integer)obj;
// int score = inScore.intValue();//jdk 5.0之后：int score = (int)obj;if(maxScore - score <= 10){level = 'A';}else if(maxScore - score <= 20){level = 'B';}else if(maxScore - score <= 30){level = 'C';}else{level = 'D';}System.out.println("student-" + i + " score is " + score + ",level is " + level);}}
}
资料来源：https://www.bilibili.com/video/BV1Kb411W75N?t=6&p=6
JavaSE：第5章 面向对象编程(中)相关推荐
- Kotlin极简教程：第7章 面向对象编程
原文链接:https://github.com/EasyKotlin 在前面的章节中,我们学习了Kotlin的语言基础知识.类型系统.集合类以及泛型相关的知识.在本章节以及下一章中,我们将一起来学习K ...
- 《PHP精粹：编写高效PHP代码》——第1章面向对象编程
本节书摘来自华章社区<PHP精粹:编写高效PHP代码>一书中的第1章面向对象编程,作者:(美) Davey Shafik,更多章节内容可以访问云栖社区"华章社区"公众号 ...
- Matlab AppDesigner编程教程第1章——面向对象编程
Matlab AppDesigner编程教程第1章--面向对象编程 文章目录 Matlab AppDesigner编程教程第1章--面向对象编程 前言 一.什么是面向对象编程 二.使用步骤 1.新建类 ...
- 《Kotin 极简教程》第7章 面向对象编程（OOP）(1)
第7章 面向对象编程(OOP) 最新上架!!!< Kotlin极简教程> 陈光剑 (机械工业出版社) 可直接打开京东,淘宝,当当===> 搜索: Kotlin 极简教程 http:/ ...
- 非零基础自学Java (老师：韩顺平) 第10章 面向对象编程(高级部分) 10.6 抽象类
非零基础自学Java (老师:韩顺平) ✈[[零基础 快速学Java]韩顺平 零基础30天学会Java] 第10章 面向对象编程(高级部分) 文章目录 非零基础自学Java (老师:韩顺平) 第10章 ...
- Java基础学习——第六章 面向对象编程(下)
Java基础学习--第六章 面向对象编程(下) 一.关键词:static 1. static关键字的引入 当我们编写一个类时,其实就是在描述其对象的属性和行为,而并没有产生实质上的对象,只有通过new ...
- 《Python编程无师自通》第13章 面向对象编程的四大支柱
第13章 面向对象编程的四大支柱 "优良设计创造价值的速度,快于其增加成本的速度." --托马斯·C.盖勒(Thomas C.Gale) 面向对象编程有四大概念:封装.抽象.多态和 ...
- c语言面向对象编程中的类_C ++中的面向对象编程
c语言面向对象编程中的类 Object oriented programming, OOP for short, aims to implement real world entities like ...
- 第7章 面向对象编程（OOP） 《Kotin 编程思想·实战》
第7章 面向对象编程(OOP) 7.1 面向对象思想 7.2 类与继承 7.2.1 类 7.2.1.1 抽象类 7.2.1.2 接口 7.2.1.3 枚举 7.2.1.4 注解 7.2.1.5 静态类 ...
最新文章
- java字节流6_JavaIO流之字节流
- mysql逻辑删除的区别_不能和逻辑删除一起配置，不然报错。
- 目前流行的装修风格_当下最流行的十大装修风格。目前主流的装修风格前十
- 十年编程经验输给新晋AI工程师，6个月我们带你绝地反击
- java验证码的实现
- ContextLoaderListener.contextInitialized - how is WebApplicationContext created
- Mac OS X 启动时自动连接网络驱动器
- 网路收报流程-网桥的处理流程（br网桥）（四）
- ODBC安装及数据源配置
- CSDN博客下载器v1.0发布(Windows版本)
- jsp实现简单购物车页面
- php amr时长,amr是什么文件
- 贷超分销系统的模式！
- 手机电子邮件设置exchange方式登录163邮箱
- Python-QRCode使用
- [BZOJ1911] [Apio2010]特别行动队
- MANIFEST.MF文件详解
- 饿了么table后台排序以及分页问题
- 版本控制系统GIT和SVN的区别
- ETAP仿真时移相变压器的设置