Java基础（三）面向对象（下）
Java基础（三）面向对象（下）
接口
接口中成员修饰符是固定的：
成员常量：public static final 成员函数：public abstract
通过接口间接实现了多重继承
接口的特点
接口是对外暴露的规则 接口是程序的工功能扩展 接口的出现降低耦合性 接口可以用来多实现 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口 接口与接口之间可以有继承关系
接口与抽象类
抽象类体现继承关系，一个类只能单继承 接口体现实现关系，一个类可以多实现
抽象类中可以定义非抽象方法，供子类直接使用 接口的方法都是抽象，接口中的成员都有固定修饰符
一个简单的实现例子：
package study_java.ex7;
public class InterfaceDemo1 {
public static void main(String[] args){
PC pc = new PC();
Mouse m = new Mouse();
Iphone ip = new Iphone();
pc.insertUSB(m);
pc.insertUSB(ip);
}
}
// 定义接口
interface USB{
void connect();
}
// 类实现了接口
class Mouse implements USB{
public void connect(){
System.out.println("我是鼠标");
}
}
class Iphone implements USB{
public void connect(){
System.out.println("我是Iphone");
}
}
class PC {
public void insertUSB(USB usb){
System.out.println("插入了usb设备");
usb.connect();
}
}如果有多个接口，并且接口存在继承的时候，代码例子如下：
package study_java.ex7;
public class InterfaceDemo2 {
public static void main(String[] args){
TuHao th = new TuHao();
WomanStar ws = new WomanStar();
th.marry(ws);
}
}
interface White{
public void white();
}
interface Rich{
public void rich();
}
interface Beautiful{
public void beautiful();
}
interface BFM extends White,Rich,Beautiful{
}
class WomanStar implements BFM{
public void white(){
System.out.println("我很白");
}
public void rich(){
System.out.println("我很有钱");
}
public void beautiful(){
System.out.println("我很有漂亮");
}
}
class TuHao{
public void marry(BFM bfm){
bfm.white();
bfm.rich();
bfm.beautiful();
}
}多态
定义：某一类事物的多种存在形态
多态的特点：
成员函数 编译时：要查看引用变量所属类中是否有所调用的成员
在运行时：要查看对象所属类是否有所调用的成员 成员变量 只看引用变量所属的类
关于多态的一个代码例子：
package study_java.ex7;
public class MutilstateDemo1 {
public static void main(String[] args){
Jing8 jing8 = new Jing8();
jing8.meng();
jing8.cry();
Dog dog = new Jing8();
dog.cry();
dog.watch();
Animal a = dog;
a.cry();
Pet pet = (Pet) a;
pet.meng();
}
}
abstract class Animal{
public void cry(){
System.out.println("crying...");
}
}
class Dog extends Animal{
public void watch(){
System.out.println("来人了");
}
}
class Jing8 extends Dog implements Pet{
public void meng(){
System.out.println("么么哒");
}
}
interface Pet{
void meng();
}继承中方法可以被覆盖，但是成员变量不能被覆盖
代码例子：
package study_java.ex7;
public class MultiStatDemo2 {
public static void main(String[] args){
Jing8 j = new Jing8();
j.cry();
Dog dog = j;
dog.cry();
System.out.println(j.name);
System.out.println(dog.name);
}
}
abstract class Animal{
abstract public void cry();
}
class Dog extends Animal{
public String name = "大黄";
public void cry(){
System.out.println("旺旺");
}
}
class Jing8 extends Dog{
public String name = "小黄";
public void cry(){
System.out.println("嘿嘿");
}
}异常
异常的体系： Throwable: Error:通常出现重大问题如：运行的类不存在或者内存溢出，不编写代码针对处理 Exception:运行时出现的一些情况，可以通过try catch finally
Exception 和Error的子类名都是以父类名作为后缀的
Trowable中的方法
getMessage():获取异常信息，返回字符串
toString():获取异常信息和异常类名，返回字符串
printStackTrace():获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void
printStackTrace(printStram s):通常用该方法将异常内容保存在日志文件中
throws和throw
throws用于标识函数暴露出的异常 throw用于抛出异常对象 throws和throw的区别： throws用在函数上，后面跟异常类名，声明抛出异常时使用的关键字 throw用在函数内，后面跟异常对象，抛出异常的语句
异常处理
try { 需要检测的代码 } catch { 异常处理代码 } finally { 一定会执行的代码 }
Finally代码只有一种情况不会被执行，就是在之前执行了System.exit(0)
package study_java.ex8;
public class ThrowableDemo1 {
public static void main(String[] args){
float r = divide(4,0);
System.out.println(r);
int[] arr = null;
int[] arr2 = new int[4];
// System.out.println(getLength(arr2));
System.out.println(getLength(arr));
}
public static float divide(int a, int b){
return (float) a / b;
}
public static int getLength(int[] arr){
int len = -1;
try {
len = arr.length;
}
catch (Exception e){
System.out.println("出错了"+ e.getMessage());
// return -2; 这里一般也不会加return
}
finally {
len += 1;
System.out.println("程序执行完了");
// return len; 这里一般不会加return
}
return len;
}
}自定义异常
自定义类继承Exception或者其子类
通过构造函数定义异常信息
通过throw将自定义异常抛出
一个简单的例子：
package study_java.ex7;
public class ExceptionDemo1 {
public static void main(String[] args){
Person p = new Person();
try{
p.setAge(1000);
}
catch (Exception e){
((AgeTooBigException)e).printlnError();
}
}
}
class Person{
private int age;
public int getAge(){
return age;
}
public void setAge(int age) throws AgeTooBigException {
if (age > 200) {
throw new AgeTooBigException();
}
this.age = age;
}
}
class AgeTooBigException extends Exception{
private String info;
public AgeTooBigException(String info){
this.info=info;
}
public AgeTooBigException(){
this("年龄太大了");
}
public void printlnError(){
System.out.println(info);
}
}一个稍微复杂的例子：
package study_java.ex7;
public class ExceptionDemo1 {
public static void main(String[] args){
Person p = new Person();
try{
p.setAge(-10);
}
catch (AgeTooBigException e){
e.printlnError();
}
catch (AgeTooSmallException e){
e.printlnError();
}
catch (AgeInvalidException e){
e.printlnError();
}
}
}
class Person{
private int age;
public int getAge(){
return age;
}
public void setAge(int age) throws AgeTooBigException,
AgeTooSmallException,
AgeInvalidException {
if (age > 200) {
throw new AgeTooBigException();
}
else if (age <10 && age > 0){
throw new AgeTooSmallException();
}
else if (age < 0){
throw new AgeInvalidException("年龄非法");
}
else{
this.age = age;
}
}
}
// 年龄非法异常
class AgeInvalidException extends Exception{
private String info;
public AgeInvalidException(String info){
this.info = info;
}
public void printlnError(){
System.out.println(info);
}
}
// 年龄太大异常
class AgeTooBigException extends AgeInvalidException{
public AgeTooBigException(String info){
super(info);
}
public AgeTooBigException(){
this("年龄太大了");
}
}
// 年龄太小异常
class AgeTooSmallException extends AgeInvalidException{
public AgeTooSmallException(String info){
super(info);
}
public AgeTooSmallException(){
this("年龄太小了");
}
}如果我们不处理异常而是直接抛出可以直接在man函数里抛出异常，这样就将异常抛给了java虚拟机
package study_java.ex8;
public class ExceptionDemo1 {
public static void main(String[] args) throws Exception {
Person p = new Person();
p.setAge(-10);
// 处理异常
/*
try{
p.setAge(2);
}
catch (AgeTooSmallException e){
e.printlnError();
}
catch (AgeTooBigException e){
e.printlnError();
}
catch (AgeInvalidException e){
e.printlnError();
}
*/
}
}
class Person{
private int age;
public int getAge(){
return age;
}
public void setAge(int age) throws AgeTooBigException,
AgeTooSmallException,
AgeInvalidException{
if (age> 200){
throw new AgeTooBigException();
}
else if (age < 10 && age > 0){
throw new AgeTooSmallException();
}
else if (age < 0){
throw new AgeInvalidException("年龄不合法");
}
else {
this.age = age;
}
}
}
class AgeInvalidException extends Exception{
private String info;
public AgeInvalidException(String info){
this.info = info;
}
public void printlnError(){
System.out.println(info);
}
}
class AgeTooBigException extends AgeInvalidException{
public AgeTooBigException(String info){
super(info);
}
public AgeTooBigException(){
this("年龄太大了");
}
}
class AgeTooSmallException extends AgeInvalidException{
public AgeTooSmallException(String info){
super(info);
}
public AgeTooSmallException(){
this("年龄太小了");
}
}关于异常处理的细节：
RuntimeException 以及其子类如果在函数中被throw抛出，可以不用再函数上声明抛出语句，也不是必须用try catch语句处理 一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或者异常的子类 如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常
CheckedException 待检异常，也就是非运行时异常，必须使用try catch语句处理
包的概念
对类文件进行分类管理 给类提供多层命名空间 卸载程序文件的第一行 类名的全称的是包名.类名 包也是一种封装方式
如： javac -d classes PackageDemo1.java 编译java源文件，制定存放目录 java -cp classes com.zhaofan.java.PackageDemo1 运行程序，类全限定名
包之间的访问： 被访问的包中的类权限必须是public 类中的成员权限：public 或者protected protected是为其他包中的子类提供的一种权限
如果一个类是public 文件名必须是类名
这里顺便整理一下常见的几种权限在java中：
import导入
一个程序文件中只有一个package,可以有多个import 用来导包的类，不导入包中的包
小结：
private 私有的不能继承
public
protected 受保护的，针对其他包中的子类
default 默认，不写，不同包不能继承
腾讯云开发者
