Java封装,继承,多态
文章目录
Java 封装
在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。
封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护,也加强了程式码的安全性。
一、封装的优点
- 良好的封装能够减少耦合。
- 类内部的结构可以自由修改。
- 可以对成员变量进行更精确的控制。
- 隐藏信息,实现细节。
二、实现Java封装的步骤
- 修改属性的可见性来限制对属性的访问(一般限制为private),例如:
public class Person {
private String name;
private int age;
}
- 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问
public class Person{
private String name;
private int age;
public int getAge(){
return age;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age;
}
public void setName(String name){
this.name = name;
}
}
以上实例中public方法是外部类访问该类成员变量的入口。
通常情况下,这些方法被称为getter和setter方法。
因此,任何要访问类中私有成员变量的类都要通过这些getter和setter方法。
Java继承
一、继承的概念
继承是java面向对象编程技术的一块基石,因为它允许创建分等级层次的类。
继承就是子类继承父类的特征和行为,使得子类对象(实例)具有父类的实例域和方法,或子类从父类继承方法,使得子类具有父类相同的行为。
二、继承的优缺点
优点:
1.提高代码的复用性。
2.提高代码的可维护性。
3.提高开发效率。
缺点:
提高了类与类之间的耦合性。
三、类的继承格式
在 Java 中通过 extends 关键字可以申明一个类是从另外一个类继承而来的
class 父类 {
}
class 子类 extends 父类 {
}
四、继承的特性
1.子类拥有父类非private的属性,方法。
2.子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。
3.子类可以用自己的方式实现父类的方法。(重写)
4.Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类。
//定义手机类
class Phone{
//定义手机的价格
double price = 500;
//手机都能打电话
public void call(){
System.out.println("手机可以打电话");
}
}
//定义具体的手机类:华为手机类,让其继承手机类Phone
class HuaWei extends Phone{
//定义子类特有的方法,在子类中可以直接使用父类的非私有的成员变量
public void show(){
//输出父类中定义的手机的价格
System.out.println(price);
}
}
//定义测试类
class Test{
public static void main(String[] args){
//创建子类对象
HuaWei hw = new HuaWei();
//因为继承了Phone类,所以继承了父类的属性和方法,所以可以调用父类中的call()方法
hw.call();
//调用子类特有的方法,输出父类中定义的手机价格
hw.show();
//子类对象也可以直接调用父类中非私有的成员变量
System.out.println(hw.price);
}
}
1、super 与 this 关键字
super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。
this关键字:指向自己的引用。
//定义手机类
class Phone_2{
//定义手机的价格
double price = 500;
}
//定义具体的手机类:华为手机类,让其继承手机类Phone
class HuaWei_2 extends Phone_2{
//定义手机的价格,变量名与父类相同
double price = 600;
//定义子类特有的方法
public void show(){
//这里会优先使用子类本身定义的变量price
System.out.println(this.price);
//输出父类的要使用super关键字调用
System.out.println(super.price);
}
}
//定义测试类
class Test_2{
public static void main(String[] args){
//创建子类对象
HuaWei_2 hw_2 = new HuaWei_2();
//调用子类特有的方法,输出子类本身定义的手机价格,和父类中定义的价格
hw_2.show();
//子类对象调用price
System.out.println(hw_2.price);
}
}
2、重写
在子类中定义了与父类中一模一样的成员方法(权限大于或等于父类方法的权限),此操作称之为方法重写。
当子类对象调用方法是,会优先调用自己重写后方法,如果没有重写,那么才会去调用父类中的方法。
//定义手机类
class Phone_3{
//定义打电话方法
public void call(){
System.out.println("手机可以打电话!");
}
}
//定义具体的手机类:华为手机类,让其继承手机类Phone
class HuaWei_3 extends Phone_3{
//重写父类中的打电话方法
@Override
public void call() {
//使用super关键字调用父类中的call方法
super.call();
System.out.println("华为手机当然可以打电话!");
}
}
//定义测试类
class Test_3{
public static void main(String[] args){
//创建子类对象
HuaWei_3 hw_3 = new HuaWei_3();
//优先调用子类重写后的方法
hw_3.call();
}
}
3、final关键字
final 关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:
-
声明类:
final class 类名 {//类体}
-
声明方法:
修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}
Java多态
多态是同一个行为具有多个不同表现形式或形态的能力。
一、多态的优点
- 消除类型之间的耦合关系
- 可替换性
- 可扩充性
- 接口性
- 灵活性
- 简化性
二、多态存在的三个必要条件
- 继承
- 重写
- 父类引用指向子类对象
//定义父类
public class Father {
//定义方法
public void fun(){
System.out.println("我是父类中的方法!");
}
}
//定义子类,继承父类
class Son extends Father{
//重写父类中的方法
@Override
public void fun() {
System.out.println("我是重写后的方法!");
}
}
//测试类
class Test{
public static void main(String[] args){
//多态体现,父类引用指向子类对象
Father f = new Son();
//调用重写后的方法
f.fun();
}
}
三、向上、向下转型
向上转型:
当有子类对象赋值给一个父类引用时,便是向上转型,多态的本身其实就是向上转型的过程。
向下转型:
一个已经向上转型的子类对象,使用强制类型转换,将父类引用转换为子类引用,这个过程称之为向下转型。(直接创建父类对象,无法向下转型)
//定义父类
public class Father_3 {
//父类中的成员变量
int a = 10;
//定义方法
public void fun(){
System.out.println("我是父类中的方法!");
}
}
//定义子类,继承父类
class Son_3 extends Father_3{
//子类中的成员变量
int a = 12;
//重写父类中的方法
@Override
public void fun() {
System.out.println("我是重写后的方法!");
}
//子类特有的方法
public void fun_2(){
System.out.println("我是子类特有的方法!");
}
}
//测试类
class Test_3{
public static void main(String[] args){
//多态体现,此过程为向上转型
Father_3 f3 = new Son_3();
//向下转型,强制转换
Son_3 s3 = (Son_3)f3;
//调用子类特有的成员
s3.fun_2();
System.out.println(s3.a);
}
}
四、instanceof 运算符
instanceof是一个比较运算符,它用来判断一个引用类型是否属于某个类型(要有继承和实现关系)的对象。
//定义“人”类
public class Person {
public void eat(){
System.out.println("人都要吃饭!");
}
}
//定义“我” 类,继承“人”类
class My extends Person{
public void eat(){
System.out.println("我是人,我也要吃饭!");
}
}
//定义测试类
class Test_4{
public static void main(String[] args) {
//多态体现
Person p = new My();
//判断p 是否属于Person类型
if (p instanceof Person) {
System.out.println(true);
}
//判断p 是否属于 My 类型
if (p instanceof My) {
System.out.println(true);
}
}
}