复习
1.访问修饰符
private 方法，变量 本类
默认 类，方法，变量 同一包
protected 方法，变量 不同包（继承关系）
public 类，变量，方法 任何地方
2.方法的重写
继承关系
方法名，参数列表，返回类型（子类<=父类）相同
访问修饰符 ：子类>=父类
异常（非运行时异常）：子类<=父类
作用：扩展 父类方法的功能
3.继承构造方法的调用
子类创建对象，默认调用父类的无参构造方法
如果父类没定义无参的构造方法，那么子类使用super调用父类的构造方法
4.多态：对象的多态
父类声明=子类创建
编译时多态 - 重载
运行时多态 - 重写
应用
对象造型：父子类之间的强制转换
instanceof
5.static
使用：类名.static的成员
static修饰变量：
成员变量：类变量和实例变量
static修饰方法：
静态方法：直接访问静态成员
不能重写
static块
static{}
父类静态块->子类的静态块->父类的构造块->父类的构造方法
->子类的构造块->子类的构造方法
6.final
变量：常量 常量值不能改变？？？
方法：不能被重写
类：不能有子类
final int[] NUM = {1,2,3};
NUM[0] =11;
---------------------------------------------------------
abstract
1.抽象方法：由abstract修饰的方法
2.特点：没有方法体
3.抽象类：由abstract修饰的类 ------ 模块
4.特点：不能创建对象
5.抽象类中可以没有抽象方法
6.抽象类由子类创建对象
7.子类可以创建对象，实现所有的抽象方法，
没有实现全部的抽象方法，当前类声明为抽象类
练习：定义一个类表示形状，提供获取周长和面积的方法，
然后给这个类提供子类：矩形 - 正方形，椭圆 - 圆形
1)定义抽象类Shape，两个抽象方法double getArea()和
double getLength()
2）定义子类Rectangle，（构造方法传参）
3）定义子类Oval，（构造方法传参） 周长：3.14*a*b
面积：2*3.14*b+4*(a-b)
4）定义Rectangle的子类Square
5）定义Oval的子类Circle
6）测试：计算各种图形的面积周长
-----------------------------------------------------------
interface
1.定义接口
interface 接口名{
变量：int x = 10; public static final修饰的
方法：jdk1.8之前,抽象方法，可以省略abstract，
默认的访问修饰符public
void f();
}
2.使用接口 implements
实现接口的类，要实现接口中的所有方法，才可以创建对象
如果不实现接口中的所有方法，当前类必须为abstract的类
3.接口和接口之间是继承关系
interface A{}
interface B extends A{}
interface C{}
4.类和接口之间是实现，可以实现多个接口
class Demo extends Object1 implmenents B,C{}
练习：
1.利用接口做参数，写个计算器，能完成加减乘除运算。
（1）定义一个接口ICompute
含有一个方法int computer(int n, int m)。
（2）设计四个类Add,Sub, Mul,Div分别实现此接口，
完成加减乘除运算。
（3）设计一个类UseCompute，
类中含有方法：
public void useCom(ICompute com, int one, int two)，
此方法能够用传递过来的对象调用computer方法完成运算，
并输出运算的结果。
（4）设计一个主类Test，
调用UseCompute中的方法useCom来完成加减乘除运算。
2.按如下要求编写Java程序：
（1）定义接口A，里面包含值为3.14的常量PI和
抽象方法double doubleArea(double radius)。//πr*r
（2）定义接口B，里面包含
抽象方法void setColor(String c)。
（3）定义接口C，该接口继承了接口A和B，
里面包含抽象方法
void volume(double radius,double height)//πr*r*h
（4）定义圆柱体类Cylinder实现接口C
---------------------------------------------------------
接口jdk8新特性：
1.接口中可以定义普通方法
default void test(){
System.out.println("test");
}
static void test2(){
System.out.println("test2");
}
2.default修饰的方法由实现类调用
static修饰的方法可以由接口名直接调用
接口不能创建对象
3.实现类的接口和父类定义了同名方法，如何访问
访问父类的方法
4.如果两个接口中都定义了同名方法，如何访问？出现编译错误
子类必须重写同名方法
5.函数式接口：
接口中只有一个抽象方法。
接口和抽象类的区别
抽象类 接口
模板类 不同类型的公共的行为（规范JDBC）
不能多继承 可以多继承
有构造方法 没有构造方法
变量是普通的变量 都是公有静态常量
普通方法 普通方法由 default或者static修饰
抽象方法没有默认访问修饰符 访问 修饰符是public
----------------------------------------------------------
内部类
1.类体内部类
//可以访问外部类的成员
//不可以定义静态成员，但是可以定义静态常量
//Demo1.Inner inner = new Demo1().new Inner();
class Inner{
final static int b =0;
int a;
void test3(){
x = 0;
y = 9;
System.out.println("test3");
}
}
//可以访问外部静态成员
//可以定义静态和非静态成员
//Demo2.Inner inner = new Demo2.Inner();
static class Inner{
int a=0;
static int b = 9;
void f(){
y = 9;
System.out.println(y);
}
}
2.方法内的内部类
void f(){
int a = 9;
//可以访问外部类的成员
//不能定义静态成员，但是可以定义静态常量
//方法内的变量被内部类访问后，变量别表示为常量
class Inner{
int b=0; //jdk1.7之后默认常量
final static int c = 0;
void f(){
int r = a+0;
x = 0;
y = 9;
System.out.println("!!!!!");
}
}
new Inner().f();
}
3.匿名类
//创建子类的对象
Object obj = new Object(){
@Override
public String toString() {
return "Hello";
}
};
//接口的实现类
IDemo demo = new IDemo(){
@Override
public void f() {
System.out.println("接口方法的实现");
}
};
//方法的参数使用匿名类实现
public void test(IDemo demo){
demo.f();
}
public static void main(String[] args) {
Demo4 demo4 = new Demo4();
demo4.test(new IDemo(){
@Override
public void f() {
System.out.println("接口方法的实现");
}
});
}
------------------------------------------------------
匿名类练习
interface IA{ void ma(); }
class MyClass {
public static void method(IA ia){
System.out.println(“in method” );
ia.ma();
}
}
public class TestInnerClass{
public static void main(String args[]){
MyClass.method(new IA(){
public void ma(){
System.out.println(“ma in anonymous inner class” );
}
});
class MyMaClass implements IA{
public void ma(){
System.out.println(“ma in local inner class” );
}
}
MyClass.method(new MyMaClass());
}
}