JAVA面向对象笔记总结(下)_interface a {public void eat();interface b {public-CSDN博客

本文链接：https://blog.csdn.net/wangliujieok/article/details/8748684

------- android培训、java培训、期待与您交流！ ----------

29 接口:

初期理解,可以认为是一个特殊的抽象类
当抽象类中的方法都是抽象的,那么该类既可以通过接口的形式来表示

class用于定义类
interface用于定义接口

接口定义时,格式特点:
1. 接口中常见定义: 常量,抽象方法
2. 接口中的成员都有固定修饰符
常量: public static final
方法: public abstract

知识点:接口中的成员都是public的

接口:

---是不可以创建对象的,因为有抽象方法
需要被子类实现,子类对接口中的抽象方法全部覆盖后,子类才可以实例化
否则子类是一个抽象类

接口可以被类多实现,也是对多继承不支持的转换形式,java多实现就可以了
一个类只能继承一个父类,但可以实现多个接口

接口之间也有关系:接口可以继承接口,并且可以多继承

//覆盖接口示例1
interface A
{}
interface B extends A
{}
interface C extends B
{}
interface D extends A imlements B,C
{
//接口D继承了A 实现了B,C 那么需要对接口A,B,C中三个方法进行覆盖
public void methodA(){};
public void methodB(){};
public void methodC (){};
}

//接口示例2
interface Inter
{
public static final int NUM = 3;
public abstract void show();
//因为有固定修饰符,所以可以简写,为了阅读性更好不建议简写
//int NUM = 3;
//void show();
}
interface InterA
{
public abstract void method();
}

class Test implements Inter,InterA
{
public void show(){}
public void method(){}

}

class InterfacDemo01
{
public static main(String[] args)
{
Test t =new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
}
}

//接口示例3:
class Student
{
abstract void study();
void sleep()
{
System.out.println("休息");
}

}
//抽烟是个别人行为,所以单独定义一个接口,抽烟的学生实现这个接口即可
//接口是扩展功能用的 ,扩展功能是定义在接口中的,
interface Smoking
{
void smoke();
}

class ZhangSan extends Student implements Smoking//张三继承了学生类,实现了抽烟接口
{
void show(){}
public void smoke(){}//张三就实现了抽烟接口

}

class Lisi extends Student
{
void show(){}//这个学生不抽烟不需要实现抽烟的接口
}
class InterfacDemo01
{
public static main(String[] args)
{
//创建张三李四实体
}
}

//接口示例4
//电脑运行控制,电脑运行基于主板
interface PCI
{
public abstract void open();
public abstract void close();
}
class MainBord
{
public void run()
{
System.out.println("MainBord run...........");
}
public void usePCI(PCI p)
{
p.open();
p.close();
}
}
class SoundCard implements PCI
{
public void open()
{
System.out.println("SoundCard run...........");
}
public void close()
{
System.out.println("SoundCard close...........");
}

}
class NetCard implements PCI
{
public void open()
{
System.out.println("NetCard run...........");
}
public void close()
{
System.out.println("NetCard close...........");
}
}

class DuoTaiDemo01
{
public static void main(String[] args)
{
MainBord mb = new MainBord();
mb.run();
mb.usePCI(new SoundCard());
mb.usePCI(new NetCard());

}
}

30多态:

------可以理解为事物存在的多种形态

1.多态的基本体现:
------父类的引用指向了自己的子类对象
父类的引用也可以接收自己的
2.多态的前提:
------必须是类与类之间有关系,要么继承,要么实现
通常还有一个前提.存在覆盖
3.多态的好处;
------多态的出现大大提高了程序的扩展性.
4.多态的弊端:
------体高了扩展性,但是只能使用父类的引用访问父类的成员
5.多态的应用:

//多态示例1:
abstract class Animal
{
public abstract void eat();
public abstract void pao();
public abstract void wan();
}

class Cat extends Animal
{
public void eat()
{
System.out.println("猫吃鱼.............");
}
public void pao()
{
System.out.println("猫再跑.............");
}
public void wan()

{
System.out.println("猫在玩.............");
}
}

class Dog extends Animal
{
public void eat()
{
System.out.println("gou吃骨头.............");
}
public void pao()
{
System.out.println("gou在跑.............");
}
public void wan()
{
System.out.println("gou在玩.............");
}
}

class DuoTaiDemo01
{
public static void main(String[] args)
{
Animal c = new Cat();
method(c);
Animal d = new Dog();
method(d);

}

//相同的特性抽取出来封装成函数,直接调用即可
public static void method(Animal a)
{
a.eat();
a.pao();
a.wan();
}
}

//多态示例2:
abstract class Student
{
public abstract void study();
public void sleep()
{
System.out.println("躺着睡....");
}
}

class BaseStudent extends Student
{
public void study()
{
System.out.println("基础班在学习....");
}
public void sleep()
{
System.out.println("站着睡....");
}
}
class AdvStudent extends Student
{
public void study()
{
System.out.println("就业班在学习....");
}
public void sleep()
{
System.out.println("趴着睡....");
}
}

class DoStudent
{
public static void method(Student st)
{
st.study();
st.sleep();
}
}

class StudentDemo
{
public static void main(String[] args)
{

DoStudent ds = new DoStudent();
ds.method(new BaseStudent());
ds.method(new AdvStudent());

//AdvStudent as = new AdvStudent();
// method(as);

}

// public static void method(Student st)
// {
// st.study();
// st.sleep();
// }

}

//数据库的例子
interface Base
{
public abstract void insert();
public abstract void delete();
public abstract void update();
public abstract void select();
}
class MySql implements Base
{
public void insert()
{
System.out.println("Mysql...插入操作...");
}
public void delete()
{
System.out.println("Mysql...删除操作...");
}
public void update()
{
System.out.println("Mysql...修改操作...");
}
public void select()
{
System.out.println("Mysql...查询操作...");
}
}

class Oracle implements Base
{
public void insert()
{
System.out.println("Oracle...插入操作...");
}
public void delete()
{
System.out.println("Oracle...删除操作...");
}
public void update()
{
System.out.println("Oracle...修改操作...");
}
public void select()
{
System.out.println("Oracle...查询操作...");
}
}
class Db
{
public static void db(Base d)
{
d.insert();
d.delete();
d.update();
d.update();
}
}

class DbBase
{
public static void main(String[] args)
{
Db dd = new Db();
dd.db(new MySql());
dd.db(new Oracle());
}
}

31 Object 超类:

----是所有对象的直接或者间接父类,传说中的上帝
该类定义的是所有对象都具备的功能

----Object类中已经提供了对对象是否相同的方法

如果自定义类中也有相同的比较方法,没有必要重新定义
只要沿袭父类中的功能, 建立自己也有的比较内容即可,这就是覆盖

//建立自己的比较方式
//引出比较方式
class Demo
{
private int x = 3;
Demo(int x)
{
this.x =x;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Demo))
return false;
Demo d = (Demo)obj;
return this.x ==d.x;
}
public String toString()
{
return "Demo:"+x;
}
}

class ObjectDemo
{
public static void main(String[] args)
{
Demo d1 = new Demo(5);
Demo d2 = new Demo(5);
System.out.println(d1.equals(d2));
System.out.println(d1.toString());//打印哈希值

}
}

32 内部类: 将一个类定义在另一个类内部

内部类访问规则:
1.内部类可以访问外部类中的成员,包括私有.
2.之所以能访问外部类中的成员,是因为内部类持有了一个外部类的引用
格式外部类名.this

访问格式:
1 当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中,可以直接建立内部类对象
格式外部类名.内部类名变量名 = 外部类对象.内部类对象
2.当内部类在成员位置上,就可以被成员修饰符所修饰
比如private ,将内部类在外部类中进行封装
内部类可以被static修饰,内部类就具备了静态的特性
只能访问外部类中的静态成员了出现了访问局限

注意:当内部类中定义了静态成员,那么内部类也必须是静态的

class Outer
{
int x = 3;

//内部类
class Inner
{
void function()
{
System.out.println("x="+x);//此处是Outer.this.x,可以省略
}

}
public void method()
{
Inner in =new Inner();
in.function();
//System.out.println("x="+x);
}
}
class OuterDemo1
{
public static void main(String[] args)
{
Outer.Inner in =new Outer().new Inner();
in.function();
//in.method();
//Outer out = new Outer();

}
}

//静态内部类代码示例
class Outer
{
private static int x = 3;
static class Inner1//静态内部类
{
static void function()
{
System.out.println("x1="+x);
}
}
static class Inner2
{
static void show()
{
System.out.println("x2="+x);
}
}
public static void method()
{
new Inner1().function();
new Inner2().show();
}
}
class InnerStaticDemo
{
public static void main(String[] args)
{
Outer.method();
}
}

//局部内部类代码示例
class Outer
{
int x =3;
void method()
{
//局部内部类
class Inner
{
void fuction()
{
System.out.println("x="+x);
}
}
new Inner(). fuction();//方法内部创建对象调用内部类对象

}
}
class InnerStaticDemo
{
public static void main(String[] args)
{
new Outer().method();//创建外部类对象调用方法
}
}

33 异常处理:

Throwable
|--error
|--Exception:就是在程序运行过程中出现的不正常情况

//异常处理简单示例1
class Demo
{
int div(int x , int y)
{

return x/y;//除数为0异常
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,0);
System.out.println(x);
}
catch (Exception e)
{
System.out.println("除数不能为零");
System.out.println(e.getMessage());//打印错误信息
System.out.println(e.toString());//打印详细错误信息
e.printStackTrace();//打印更详细的错误信息
}
System.out.println("over");
}
}

//异常声明throws
class Demo
{
int div(int x , int y) throws Exception//在功能上通过throws的关键字声明了该功能可能会出问题
{
return x/y;//除数为0异常
}
}
class ExceptionDemo
{
public static void main(String[] args) throws Exception
{
Demo d = new Demo();
int x = d.div(4,1);
System.out.println(x);

System.out.println("over");
}
}

多异常处理:

class Computer
{
private int x = 1;
if(x==1)
public void run()
{
System.out.println("电脑运行了...");
}

}
class Teacher
{
public void tech()
{
run();
System.out.println("老师开始上课...");
}
}
class ExceptionTest01
{
public static void main(String[] args)
{
Computer c = new Computer();
int x = c.tech();
}
}

34 finally语句块:

格式:
try
{
//可能出现异常的代码
}
catch
{
//处理异常代码
}
finally
{
//必须执行的代码
}

知识点:finally 无论是否发生异常,finally语句块是必须执行的

35 继承关系中的异常:

1. 父类方法抛出异常,子类覆盖父类方法可以不抛出异常
2. 父类方法不抛出异常,子类覆盖父类方法,子类绝对不能抛出异常
3. 子类覆盖没有抛出异常的父类的情况下,子类调用了一个抛出异常的方法,子类只能使用try..catch
4. 子符类异常,在子父类中的体现
|---子类抛出的异常,绝对不可以大于父类抛出的异常
|---子类抛出的异常不能是父类抛出异常以外的体系
5. 当一个try对应多个catch时,在catch的括号中,异常是有顺序的
最高父类写在下面,依次类推,最小的子类写在最上面catch中