第一 抽象类
一、概括:
当多个类出现相同功能,但是功能主体不同是,这样就可以向上抽取,抽取时只抽取功能定义,而不抽取功能主体。这是我们就把抽取出来的功能主体因为没有具体的方法体,对于我们来说也就是看不懂的,用一个专业的词来形容就是抽象,抽象用一个特殊的关键字abstract来修饰,特别说明下类中有抽象方法时那么该类也就是抽象的,也必须用abstract来修饰。
二、抽象类的特点:
1、抽象方法一定在抽象类中。
2、抽象方法和抽象类都必须被abstract关键字修饰。
3、抽象类不可以用new创建对象。因为调用抽象方法没意义。
4、抽象类中的抽象方法要被使用,必须由子类复写其所有的抽象方法后,建立子类对象调用。如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
总结:抽象类和一般类没有太大的不同。该如何描述事物,就如何描述事物,只不过,该事物出现了一些看不懂的东西。这些不确定的部分,也是该事物的功能,需要明确出来。但是无法定义主体,通过抽象方法来表示。特殊:抽象类中可以不定义抽象方法,这样做仅仅是不让该类建立对象。
三、abstract 关键字,和哪些关键字不能共存。
1、final:被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
2、private: 抽象类中的私有的抽象方法,不被子类所知,就无法被复写。而抽象方法出现的就是需要被复写。
3、static:如果static可以修饰抽象方法,那么连对象都省了,直接类名调用就可以了。可是抽象方法运行没意义。
四、抽象类中是否有构造函数?
有,抽象类是一个父类,要给子类提供实例的初始化。
/*
假如我们在开发一个系统时需要对员工进行建模,员工包含 3 个属性:
姓名、工号以及工资。经理也是员工,除了含有员工的属性外,另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
员工类:name id pay
经理类:继承了员工,并有自己特有的bonus。
*/
class Employee
{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay)
{
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
class Manager extends Employee
{
private int bonus;
Manager(String name,String id,double pay,int bonus)
{
super(name,id,pay);
this.bonus = bonus;
}
public void work()
{
System.out.println("manager work");
}
}
class Pro extends Employee
{
Pro(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("pro work");
}
}
class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
一、概述:
接口:初期理解,可以认为是一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。class用于定义类,interface 用于定义接口。
二、接口定义时,格式特点:
1、接口中常见定义:常量,抽象方法。
2、接口中的成员都有固定修饰符。
常量:public static final
方法:public abstract
记住:接口中的成员都是public的。
三、特点:
1、接口:是不可以创建对象的,因为有抽象方法。
2、需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化。否则子类是一个抽象类。
3、接口可以被类多实现,也是对多继承不支持的转换形式。java支持多实现。接口与接口之间可以多继承。
interface Inter
{
public static final int NUM = 3;
public abstract void show();
}
interface InterA
{
public abstract void show();
}
class Demo
{
public void function(){}
}
class Test extends Demo implements Inter,InterA
{
public void show(){}
}
interface A
{
void methodA();
}
interface B //extends A
{
void methodB();
}
interface C extends B,A
{
void methodC();
}
class D implements C
{
public void methodA(){}
public void methodC(){}
public void methodB(){}
}
class InterfaceDemo
{
public static void main(String[] args)
{
Test t = new Test();
System.out.println(t.NUM);
System.out.println(Test.NUM);
System.out.println(Inter.NUM);
}
}
说明:
1、类与类之间不能对继承,原因是多个父类中有同名函数,子类在运行的时候不知道运行那块代码。
2、java可以多实现,原因是接口都是抽象的,抽象方法没有方法体,不管有没有相同的函数,子类都只需要覆盖一次就可以了。
3、接口与接口之间可以多继承:因为接口中都是抽象方法,不存在方法体,也都需要子类去覆盖,所以不存在模糊的调用的。
四、接口的特点:
1、接口是对外暴露的规则
2、接口是程序的扩展功能
3、接口可以多实现
4、接口与接口之间可以多继承
5、接口降低了代码的耦合性
6、类与接口之间是实现关系,一个类可以继承一个类的同时去实现多个接口。
注意:两个或多个接口中不允许有返回值类型不同的同名函数
public class AB implements A, B {
@Override
public void method() {
}
public int method() {
}
}
interface A {
public abstract void method();
}
interface B {
public abstract int method();
}
这代码是有错的,因为在类实现了两个接口后有两个方法名相同,但是返回值类型不同的方法,这是没有构成重载的,所以不能同时存在一个类中。
第三 抽象类与接口的区别和联系
一、区别:
第一、与类的关系不同
1、抽象类是一种被子类继承的关系(类与类之间单继承)
2、接口与类之间是实现关系(一个类能实现多个接口)
3、接口与接口之间是继承关系(接口之间可以多继承)
第二、定义特点不同
1、抽象类可以定义变量、非抽象类、抽象类
变量:private、public、final、static等等修饰符
抽象方法:abstract(必须有)、public、static等等修饰符
2、接口可以定义常量、抽象类
常量:public static final(只能赋值一次)
方法:public abstract
3、权限不同:
抽象类可以有私有变量或方法(抽象方法不能为私有),子类继承抽象父类必须复写全部的抽象方法
接口是公开(public)的,里面不能有私有方法,因为接口是对外暴露的,是提供给外界使用的;实现接口必须重写接口中的全部抽象方法
4、成员不同:抽象类中可以有自己的成员,也可以由非抽象的成员方法。
接口中只能有静态的不能被修改的成员变量(即常量),而且所有成员方法皆为抽象的。
5、变量不同:
抽象类中的变量默认是friendly型的,即包内的任何类都可以访问它,而包外的任何类都不能访问它(包括包外继承了此类的子类),其值可以在子类中重新定义,也可重新赋值。
接口中定义的变量是默认的public static final,且必须进行初始化即赋初值,并不可改变。
二、联系
1.其实接口是抽象类的延伸,可以将它看做是纯粹的抽象类,就是说接口比抽象类还抽象。
2、抽象类和接口都必须被一个类(子类)复写里面的全部抽象方法。
3、接口和抽象类都不可创建对象,因为其中含有抽象方法,需要被子类实现后,对接口中抽象方法全覆盖后,子类才可以实现实例化。
内部类,顾名思义就会定义在一个类里面的类就称为内部类。一个内部类可以定义在外部类的成员位置上,也可以定在函数内部作为局部存在。
二、内部类的访问规则:
1、内部类可以直接访问外部类中的成员,包括私有。之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式 外部类名.this
2、外部类要访问内部类,必须建立内部类对象。
三、访问格式:
1、当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中。可以直接建立内部类对象。
格式
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
2、当内部类在成员位置上,就可以被成员修饰符所修饰。比如,private:将内部类在外部类中进行封装。static:内部类就具备static的特性。当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中,如何直接访问static内部类的非静态成员呢?new Outer.Inner().function();
在外部其他类中,如何直接访问static内部类的静态成员呢?uter.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是static的。当外部类中的静态方法访问内部类时,内部类也必须是static的。
class Outer
{
private static int x = 3;
static class Inner//静态内部类
{
static void function()
{
System.out.println("innner :"+x);
}
}
static class Inner2
{
void show()
{
System.out.println("inner2 show");
}
}
public static void method()
{
//Inner.function();
new Inner2().show();
}
}
class InnerClassDemo2
{
public static void main(String[] args)
{
Outer.method();
//Outer.Inner.function();
//new Outer.Inner().function();
//直接访问内部类中的成员。
// Outer.Inner in = new Outer().new Inner();
// in.function();
}
}
四、内部类定义原则:
1、当描述事物是,事物的内部还有事物,则该事物用内部类来描述。如人与心脏的关系。
2、何时定义内部类:当一个类需要直接访问另一个的成员时,则将这个类放在另一个类的内部,并将此类封装。
局部内部类:当内部类只在外部类中的某个方法中,创建了这个类型的对象时,且仅使用了一次,那么可在这个方法中定义局部类。
注:
1、局部内部类不可用public或者private访问修饰符声明,它的作用域被限定在了声明这个局部类的代码块中
2、局部类的优势:
a.对外界完全隐藏,即使此方法所在的类也不可访问,也就是说,除此方法外,无任何方法知道它的存在。
b.可访问包含他们的外部类,因还持有外部类的引用;还可访问局部变量,但是局部变量必须被声明为final。
需要注意:局部内部类不可悲成员修饰符修饰,如static
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);
}
}
new Inner().function();
}
}
class InnerClassDemo3
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);
out.method(8);
}
}
在上面的代码中既传了7(out.method(7);)又传了8(out.method(8);)这是可以的,因为函数中的final int a是局部变量,加载在栈内存中,随着对象的消亡而消亡了。
五、匿名内部类:
1、匿名内部类其实就是内部类的简写格式。
2、定义匿名内部类的前提:内部类必须是继承一个类或者实现接口。
3、匿名内部类的格式: new 父类或者接口(){定义子类的内容}
4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
5、匿名内部类中定义的方法最好不要超过3个。
abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x = 3;
/*
class Inner extends AbsDemo
{
int num = 90;
void show()
{
System.out.println("show :"+num);
}
void abc()
{
System.out.println("hehe");
}
}
*/
public void function()
{
//AbsDemo a = new Inner();
// Inner in = new Inner();
// in.show();
// in.abc();
AbsDemo d = new AbsDemo()//new AbsDemo()匿名内部类的子类对象,多态
{
int num = 9;
void show()
{
System.out.println("num==="+num);
}
void abc()
{
System.out.println("haha");
}
};
d.show();
//d.abc();//编译失败;不能向下转型
}
}
class InnerClassDemo4
{
public static void main(String[] args)
{
new Outer().function();
}
}
练习:
interface Inter
{
void method();
}
class Test
{
//补足代码。通过匿名内部类。
/*
static class Inner implements Inter
{
public void method()
{
System.out.println("method run");
}
}
*/
static Inter function()
{
return new Inter()
{
public void method()
{
System.out.println("method run");
}
};
}
}
class InnerClassTest
{
public static void main(String[] args)
{
//Test.function():Test类中有一个静态的方法function。
//.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
//因为只有是Inter类型的对象,才可以调用method方法。
Test.function().method();
// Inter in = Test.function();
// in.method();
show(new Inter()
{
public void method()
{
System.out.println("method show run");
}
});
}
public static void show(Inter in)
{
in.method();
}
}
class InnerTest
{
public static void main(String[] args)
{
new Object()
{
public void function()
{
}
}.function();
}
}
第五 模版方法设计模式
什么是模版方法呢?在定义功能时,功能的一部分是确定的,但是有一部分是不确定,而确定的部分在使用不确定的部分,那么这时就将不确定的部分暴露出去。由该类的子类去完成。
/*
需求:获取一段程序运行的时间。
原理:获取程序开始和结束的时间并相减即可。
获取时间:System.currentTimeMillis();
当代码完成优化后,就可以解决这类问题。
这种方式,模版方法设计模式。
*/
abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();
runcode();
long end = System.currentTimeMillis();
System.out.println("毫秒:"+(end-start));
}
public abstract void runcode();
}
class SubTime extends GetTime
{
public void runcode()
{
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
}
class TemplateDemo
{
public static void main(String[] args)
{
//GetTime gt = new GetTime();
SubTime gt = new SubTime();
gt.getTime();
}
}
二、异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。
1、对于问题的划分:两种:一种是严重的问题,一种非严重的问题。
2、对于严重的,java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
3、对与非严重的,java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。
异常有两种:
编译时被检测异常
该异常在编译时,如果没有处理(没有抛也没有try),编译失败。
该异常被标识,代表这可以被处理。
运行时异常(编译时不检测)
在编译时,不需要处理,编译器不检查。
该异常的发生,建议不处理,让程序停止。需要对代码进行修正。
4、无论Error或者Exception都具有一些共性内容。比如:不正常情况的信息,引发原因等。
5、异常的好处:将问题进行封装;将正常流程代码和问题处理代码相分离,方便于阅读。
6、异常的注意事项:
在子父类覆盖时:子类抛出的异常必须是父类的异常的子类或者子集;如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。
由于父类中把异常信息的操作完成了,所以子类只需要在构造函数时,将异常信息传递给父类,通过super语句,则可直接用getMessage方法,自动自定义的异常。
class FuShuException extends Exception //getMessage();
{
private int value;
FuShuException()
{
super();
}
FuShuException(String msg,int value)
{
super(msg);
this.value = value;
}
public int getValue()
{
return value;
}
}
class Demo
{
int div(int a,int b)throws FuShuException
{
if(b<0)
throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。
return a/b;
}
}
class ExceptionDemo3
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(4,-9);
System.out.println("x="+x);
}
catch (FuShuException e)
{
System.out.println(e.toString());
//System.out.println("除数出现负数了");
System.out.println("错误的负数是:"+e.getValue());
}
System.out.println("over");
}
}
/*
class Throwable
{
private String message;
Throwable(String message)
{
this.message = message;
}
public String getMessage()
{
return message;
}
}
class Exception extends Throwable
{
Exception(String message)
{
super(message);
}
}
class Person
{
String name;
Person(String name)
{
this.name = name;
}
public String getName()
{
return name;
}
}
class Student extends Person
{
Student (String name)
{
super(name);
}
}
new Sttdent("lisi").getName();
*/
五、异常处理原则
/*
毕老师用电脑上课。
开始思考上课中出现的问题。
比如问题是
电脑蓝屏。
电脑冒烟。
要对问题进行描述,封装成对象。
可是当冒烟发生后,出现讲课进度无法继续。
出现了讲师的问题:课时计划无法完成。
*/
class LanPingException extends Exception
{
LanPingException(String message)
{
super(message);
}
}
class MaoYanException extends Exception
{
MaoYanException(String message)
{
super(message);
}
}
class NoPlanException extends Exception
{
NoPlanException(String msg)
{
super(msg);
}
}
class Computer
{
private int state = 3;
public void run()throws LanPingException,MaoYanException
{
if(state==2)
throw new LanPingException("蓝屏了");
if(state==3)
throw new MaoYanException("冒烟了");
System.out.println("电脑运行");
}
public void reset()
{
state = 1;
System.out.println("电脑重启");
}
}
class Teacher
{
private String name;
private Computer cmpt;
Teacher(String name)
{
this.name = name;
cmpt = new Computer();
}
public void prelect()throws NoPlanException
{
try
{
cmpt.run();
}
catch (LanPingException e)
{
cmpt.reset();
}
catch (MaoYanException e)
{
test();
throw new NoPlanException("课时无法继续"+e.getMessage());
}
System.out.println("讲课");
}
public void test()
{
System.out.println("练习");
}
}
class ExceptionTest
{
public static void main(String[] args)
{
Teacher t = new Teacher("毕老师");
try
{
t.prelect();
}
catch (NoPlanException e)
{
System.out.println(e.toString());
System.out.println("换老师或者放假");
}
}
}