多态
是指同一行为，具有多个不同表现形式。
父类类型 变量名 = new 子类对象；
变量名.方法名();
向下转型：父类类型向子类类型 向下转换的过程，这个过程是强制的。
为了避免ClassCastException的发生
向下转型必 须使用isstanceof判断
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
接口多态的综合案例
笔记本电脑
USB接口，包含开启功能、关闭功能
public interface USB {
public abstract void open();
public abstract void close();
}
笔记本类，包含运行功能、关机功能、使用USB设备功能
public class Computer {
public void powerOn() {
System.out.println("open computer");
}
public void powerOff() {
System.out.println("close computer");
}
public void useDevice(USB usb) {
usb.open();
if (usb instanceof Mouse) {
Mouse mouse = new Mouse();
mouse.click();
} else if(usb instanceof KeyBorad) {
KeyBorad keyBorad = new KeyBorad();
keyBorad.push();
}
usb.close();
}
}
鼠标类，要实现USB接口，并具备点击的方法
public class Mouse implements USB {
@Override
public void open() {
// TODO Auto-generated method stub
System.out.println("open mouse usb");
}
@Override
public void close() {
// TODO Auto-generated method stub
System.out.println("close mouse usb");
}
public void click() {
System.out.println("click mouse");
}
}
键盘类，要实现USB接口，具备敲击的方法
public class KeyBorad implements USB {
@Override
public void open() {
// TODO Auto-generated method stub
System.out.println("open keyboad usb");
}
@Override
public void close() {
// TODO Auto-generated method stub
System.out.println("close keyboad usb");
}
public void push() {
System.out.println("push keyboard");
}
}
main
public class DemoMain {
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
USB usbMouse = new Mouse();
computer.useDevice(usbMouse);
USB keyboard = new KeyBorad();
computer.useDevice(keyboard);
computer.powerOff();
}
}
final关键字
不可改变。可以用于修饰类、方法和变量。
类：被修饰的类，不能被继承。
final class 类名 {
}
其中所有的成员方法都无法重写
方法：被修饰的方法，不能被重写。
修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
变量：被修饰的变量，不能被重新赋值。
1. 局部变量——基本类型
final int a;
2. 局部变量——引用类型
final User u = new User();（是u的地址不可改变，内容可以）
3. 成员变量
显示初始化： final String USERNAME = "张三";
构造方法初始化：final String USERNAME ;
只能二选一
被final修饰的常量名称，一般都有书写规范，所有字母都大写。
权限修饰符
public：公共的。
protected：受保护的
default：默认的
private：私有的
不同权限的访问能力
如果没有特殊的考虑，建议：
成员变量使用private ，隐藏细节。
构造方法使用public ，方便创建对象。
成员方法使用public ，方便调用方法。
内部类
将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。
修饰符 class name { //外部类
修饰符 class name { //内部类
}
}
内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类的成员，必须要建立内部类的对象。
创建内部类对象
外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；
内部类的同名访问
public class Outer {
int num =10;
public class Inner{
int num = 20;
public void method() {
int num = 30;
System.out.println(num);//局部变量
System.out.println(this.num);//内部类
System.out.println(Outer.this.num);//外部类的成员变量
}
}
}
局部内部类对象（定义在一个方法内部），只有当前所属方法才可以使用
修饰符 class 外部类名称{
修饰符 返回值类型 外部类方法名（参数）
{class 局部类名{
}}
}
public class Outer {
public void methodOuter() {
class Inner{
int num = 10;
public void methodIneer() {
System.out.println(num);
}
}
Inner inner = new Inner();
inner.methodIneer();
}
}
public class DemoO {
public static void main(String[] args) {
// TODO Auto-generated method stub
Outer objOuter = new Outer();
objOuter.methodOuter();
}
}
匿名内部类【重点】
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，
那么这种情况下可以省略该类的定义，使用【匿名函数类】
定义：
接口名称 对象名 = new 接口名称（）；{
覆盖重写所有匿名方法
}
定义接口：
public interface MyIterface {
public abstract void method();
}
创建匿名内部类，并调用：
public class DemoMMAIN {
public static void main(String[] args) {
MyIterface objIterface = new MyIterface() {
@Override
public void method() {
System.out.println("实现匿名内部类"); }
};
objIterface.method();
}
}
省略了一个单独写一实现类
public class IntfaceIplement implements MyIterface{
@Override
public void method() {
System.out.println("实现类覆盖重写了方法");
}
}
注意：
1.匿名对象在调用方法的时候，只能调用唯一一次
如果希望同一对象，调用多次方法，那么必须给对象起个名字
2.匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
匿名对象跟匿名内部类不是一回事
内部类将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。