3.1.1 自定义包

如果在程序中没有声明包，类将被存放在default的包中，该方式不被提倡。

语法：

package  包名

包命名规范：

包的命名规范应当体现出项目资源良好的划分

自定义标签类所在包命名规范：公司名称.开发组名称.项目名称

例如：com.java.explorer

声明一个包的语句必须写在类中的第一行

3.1.2 包的导入

语法：

import  包名.类名

示例：

import java.util.*; //导入java.util包中所有的类
import java.util.ArrayList; //导入java.util包中的ArrayList类

示例：在Hero类中使用Tree类，Hero类与Tree类不在同一个包中

package com.java.oriented.dota.scene;
public class Tree {public void clear(){        //具体业务逻辑}
}package com.java.oriented.dota.figure;
//由于Tree类与Hero类不在同一个包中，所以需要使用import关键字导入包
import com.java.oriented.dota.scene.Tree;
public class Hero {public void eatTree(Tree tree){//调用树对象的clear()方法，吃掉的树在地图中消失tree.clear();}
}

3.1.3 包的访问权限

一个包中具有缺省访问权限的成员只能在同一个包中被引用。

如果一个包中的成员的访问权限为 public，那么这些成员才能被其他包中的类所引用。

以上“成员”特指类、属性和方法。

public成员可以被其他包中的类访问，public类中的protected成员可以被由它派生的在其他包中的子类访问。

package com.java.oriented.dota.scene;
public class Tree {void clear(){  //去掉public    //具体业务逻辑}
}package com.java.oriented.dota.figure;
//由于Tree类与Hero类不在同一个包中，所以需要使用import关键字导入包
import com.java.oriented.dota.scene.Tree;
public class Hero {public void eatTree(Tree tree){//调用树对象的clear()方法，吃掉的树在地图中消失tree.clear();}
}

3.2 继承

继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

生活中的继承：

3.2.1 继承概述

继承是面向对象程序设计的一个重要特征，它是通过继承原有类派生出子类，进而构造出更为复杂的子类。
子类既有新定义的行为特征，又继承了原有类的行为特征。
父类与子类存在着包含与被包含的关系，是一种is-a的关系。
在Java中继承可以在现有类的基础上进行功能的扩展，这样能够更加快速地开发出新类，使新类不仅可以复用当前类的特征和行为，而且还可以定义自己的特征和行为。
通过继承可大幅度提高代码的复用性，减少代码量，便于程序的后期维护。

Java继承语法：

[修饰符] class 子类名  extends 父类名{//类定义部分
}

父类也称作基类或超类

3.2.2 继承的实现

.示例：定义父类武器，以及子类圣剑和长矛

public class Weapon { //父类  武器String name;//武器名int attackValue;//攻击值//构造方法public Weapon(String name, int attackValue) {System.out.println("--执行武器父类Weapon的构造方法--");this.name = name;this.attackValue = attackValue;}//攻击方法public void attack(){System.out.println("武器名:"+name+"\t"+"攻击值:"+attackValue);}
}
public class Sword extends Weapon{ //圣剑  子类public Sword(String name, int attackValue) {super(name, attackValue);}
}
public class Spear extends Weapon{ //圣剑  长矛//构造方法public Spear(String name,int attackValue) {super(name, attackValue);}
}
public class ExtendsTest { // 测试类public static void main(String[] args){Sword word = new Sword("圣剑",300);word.attack();Spear spear = new Spear("长矛",250);spear.attack();}
}

3.3 重载和重写

3.3.1 重载

方法重载的规则：

方法名称必须相同。

参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。

方法的返回类型可以相同也可以不相同。

仅仅返回类型不同不足以成为方法重载。

注意：

参数列表不同包括：个数不同、类型不同和顺序不同。

仅仅参数变量名称不同是不可以的。

跟成员方法一样，构造方法（构造器）也可以重载。

声明为final的方法不能被重载。

声明为static的方法不能被重载，但是能够被再次声明。

示例：在Book类中定义3个互为重载的方法，它们分别计算不同情形下图书的价格。

public class Book {//定义3个重载方法public float  getPrice(){    return 100;}public  float getPrice(int page){return (float)(page*0.1);}public  float  getPrice(int page ,float discount){return (float) (page*discount);}public static void main(String[] args) {Book book=new Book();//创建Book对象System.out.println("default图书价格:"+book.getPrice());System.out.println("根据页数计算图书价格:"+book.getPrice(268));    System.out.println("根据页数和折扣计算图书格:"+book.getPrice(360,0.2f));}
}

3.3.2 重写

在子类中可以根据需要对从父类中继承来的方法进行重写。

重写的方法和被重写的方法必须具有相同方法名称、参数列表和返回类型。重写方法不能使用比被重写的方法更严格的访问权限。

重写方法不能声明抛出比被重写方法范围更大的异常类型。

重写是外壳不变，核心变。也就是说方法名不变，参数不变，具体实现可以改变。一般是在父类中声明方法，在子类中重写。重载是方法名不变，但参数一定要变。而且重载的方法一般都写在一个类中。

提醒：

重写是子类对所继承父类相同方法的一种更改，这个更改需要遵循格式按照父类的格式。

子类重写方法的访问权限，抛出异常等等，都需在父类方法的控制范围之内，但其内部的具体实现可以不同。

子类重写方法的返回值可以为父类中被重写方法返回值的子类型；如果方法参数若为子类类型，则它们是重载而不是重写。

示例：在子类鸵鸟中重写父类飞鸟的飞翔方法

public class Bird { // 父类  飞鸟//Bird类的fly()方法public void fly(){System.out.println("我在蓝天白云间自由的飞翔...");}
}
public class Ostrich extends Bird{// 子类  鸵鸟public  void fly(){ //重写父类方法System.out.println("我只能在陆地上拍拍翅膀奔跑...");}public  void prey(){ //捕食方法fly();System.out.println("执行捕食方法");}public static void main(String[] args) {Ostrich ostrich=new Ostrich();ostrich.prey(); //调用ostrich对象的prey()}
}

3.3.3 重写覆盖问题

如果需要访问被子类覆盖的方法，则可使用super关键字指明调用父类被覆盖的实例方法。

示例：子类鸵鸟捕食时将使用父类飞鸟的飞翔功能。

public class Ostrich extends Bird{public  void fly(){System.out.println("我只能在陆地上拍拍翅膀奔跑...");}//捕食方法public  void prey(){//在prey()方法中使用super关键调用父类的fly()方法super.fly();System.out.println("执行捕食方法");}public static void main(String[] args) {//创建Ostrich对象Ostrich ostrich=new Ostrich();ostrich.prey();//调用ostrich对象的fly()}
}

3.4 多态

从一定角度来看，封装和继承几乎都是为多态而准备的。
多态是指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。
多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
在编译时，可以通过父类的引用指向子类对象，而在运行时，则通过父类所指向的子类对象，调用子类中重写父类的方法。

3.4.1 多态应用

示例：指向子类的父类引用在执行重写方法时所体现的多态性

//父类 人物
public class Figure {protected String name;public void attack(){//此处不进行具体的攻击操作，不同职业的英雄攻击方式不同}public  void run(){        System.out.println("在奔跑");}
}//子类 战士
public class Warrior  extends  Figure{//重写父类的attack()方法public void attack(){System.out.println(this.name+"正在物理攻击......");}
}
//子类 法师
public class Master extends Figure {//重写父类的attack()方法public void attack(){        System.out.println(this.name+"正在魔法攻击......");}    public static void main(String[] args) {Figure master=new Master();master.name="恶魔巫师";Figure warrior=new Warrior();warrior.name="撼地神牛";master.attack();warrior.attack();}
}

3.4.2 引用变量的强制类型转换

示例：调用父类引用的方法没有在父类进行定义


//子类 法师
public class Master extends Figure {//重写父类的attack()方法public void attack(){        System.out.println(this.name+"正在魔法攻击......");}//子类特有的轰炸功能public void bomb(){System.out.println(this.name+“正在魔法轰炸......");}    public static void main(String[] args) {Figure figure=new Master();figure.name="恶魔巫师";figure.attack();figure.bomb(); //此处编译出错}
}

分析：

引用变量只能调用其编译时类型的方法，而不能调用运行时类型的方法，即使实际所引用的对象确实包含该方法。

如果需要让引用变量调用运行时类型的方法，则必须将其强制类型转换为运行时类型，强制类型转换需借助于类型转换运算符。

3.4.3 instance of 运算符

instance of 运算符用于判断一个实例是否为某个类的实例

语法：

a instanceof A
判断实例a是否为类A的实例，如果为真则返回true，否则返回false。

//子类 法师
public class Master extends Figure {//重写父类的attack()方法public void attack(){        System.out.println(this.name+"正在魔法攻击......");}//子类特有的轰炸功能public void bomb(){System.out.println(this.name+“正在魔法轰炸......");}    public static void mafigurein(String[] args) {Figure figure=new Master();figure.name="恶魔巫师";figure.attack();if(figure instanceof Master )Master master = (Master)figure; // 使用向下类型转换master.bomb();   //成功调用Master类的bomb}
}

3.4.4 实践练习

总结：
声明包的语句是“package  包名”，该语句必须放在第一行，导入类的语句是  “import 包名.类名”。
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例  域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。
子类继承父类的语法是：“[修饰符] class 子类名   extends  父类名”。
重载就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。
重写就是在子类方法重写父类方法，重写的方法和被重写的方法必须具有相同方法名称、参数
列表和返回类型。
多态是指同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
在编译时，可以通过父类的引用指向子类对象，而在运行时，则通过父类所指向的子类对象，调用子类中重写父类的方法。

Java面向对象程序基础设计之第三章相关推荐

java面向对象程序基础实验_20165115 实验二《Java面向对象程序设计》实验报告
20165115 实验二面向对象程序设计这一次的实验,老师按照实验内容的不同将实验分成了五个部分进行.五个部分的侧重难易都有区别,实验报告中的叙述也会有所区别. 第一部分先上实验结果截图: 这一 ...
java面向对象编程基础
java面向对象编程基础前言:什么是java 是咖啡飘香的清晨 - 是斯坦福校园意浓情深 - 是James的思想睿智是剁手党双十一挥舞的利刃是大数据云计算驰骋的平台 - 是ATM上吐出的钞票 - ...
java记事本实践意义,Java记事本程序课程设计报告
Java记事本程序课程设计报告课程设计课程设计报告书报告书课程名称课程名称面向对象课程设计面向对象课程设计设计题目设计题目记事本程序记事本程序专业班级专业班级学学号号姓姓名名目录 ...
shadowplay要下载java_Java并发程序设计（二）Java并行程序基础
Java并行程序基础一.线程的生命周期其中blocked和waiting的区别: 作者:赵老师链接:https://www.zhihu.com/question/27654579/answer/ ...
Java并发程序设计（二）Java并行程序基础
Java并行程序基础一.线程的生命周期其中blocked和waiting的区别: 作者:赵老师链接:https://www.zhihu.com/question/27654579/answer/ ...
小赵老师课堂开课了！天道酬勤，相信自己学到就是赚到，一起来学习吧--- java面向对象程序设计基础的知识！！！！
大家!我是下一个pony,今天我又来更新帖子了~ 今天我们讲解的是java面向对象程序设计基础的知识~我们从以下几个方面来进行简单的讲解: ============================== ...
java面向对象程序练习_5本面向经验丰富的程序员的高级Java书籍
java面向对象程序练习 Sometimes back I wrote an article for Best Core Java Books for beginners, today I am sh ...
（二）Java并行程序基础
Java并行程序基础 2.1 线程和进程 2.2 初始线程 2.2.1 新建线程 2.2.2 线程中断 2.2.3 等待(wait)和通知(notify) 2.2.4 挂起(suspend)和继续执行 ...
Java程序设计（2021春）——第三章类的重用笔记与思考
Java程序设计(2021春)--第三章类的重用笔记与思考本章概览: 3.1 类的继承(概念与语法) 3.2 Object类(在Java继承最顶层的类) 3.3 终结类和终结方法(只能拿来用,不可以 ...

Java面向对象程序基础设计之第三章