1 接口
1.1接口的多实现
- java是单继承
- 多实现:一个类可以实现多个接口
- 一个类能继承一个父类同时实现多个接口
// 格式: public class 类名 [extends 父类] implements 接口1,接口2{}
// 必须重写接口中所有的抽象方法,默认方法可重写可不重写
public class dog extends Animal implements Livable,pat{
}
1.如果抽象方法有重名的,重写一次即可(例Livable和pat抽象方法重名,dog类只需重写一次)
2.如果默认方法有重名,必须重写一次
3.当一个类,即继承了父类,又实现了多个接口,父类中的成员方法与接口中默认方法重名(就近原则,继承)
4.存在同名的静态方法不会冲突,因为只能通过接口名去访问静态方法
// Animal类
public class Animal implements Livable{
@Override
public void func() {
}
@Override
public void show() {
}
public void eat(){
}
}
// Pat类
public interface Pat {
public void shouyang();
//抽象方法重名
void show();
//默认方法重名
default void method(){
System.out.println("Pat");
}
}
// Livable类
public interface Livable {
//静态方法的使用
public static void run(){
System.out.println("跑起来");
}
//将func1和func2封装
//私有方法
private void func1(){
System.out.println("func1()");
}
private void func2(){
System.out.println("func2()");
}
public default void func(){
func1();
func2();
}
// 抽象方法重名
public void show();
//默认方法重名
default void method(){
System.out.println("Livable");
}
}
// Dog类
public class Dog extends Animal implements Livable,Pat {
// 多实现的格式:class 类名 [extends 父类名] implements 接口1,接口2...{}
// 必须重写接口中的抽象方法
// 默认方法可重写可不重写
@Override
public void shouyang() {
System.out.println("shouyang()");
}
@Override
public void show() {
System.out.println("show()");
}
@Override
public void method() {
System.out.println("Dog");
}
public void eat(){
System.out.println("吃狗粮");
}
}
1.2接口的多继承
- 一个接口可以继承多个接口
- 如果父接口中默认方法有重名的,那么子接口需要重写
1.3其他成员特点
- 接口中,无法定义成员变量,但是可以定义常量,其值不可以改变,默认使用public static final修饰
- 没有构造方法,所以不能创建对象,也就是不能被new
- 没有静态代码块
2 多态
- 概念:同一种行为具有不同的表达形式
-
前提:
1.继承或方法的实现
2.方法的重写
3.父类引用指向子类对象
2.1 格式:父类类型 对象名 = new 子类对象
public class Animal implements Livable{
@Override
public void func() {
}
@Override
public void show() {
}
public void eat(){
}
}
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("Cat 在喵喵的吃猫粮");
}
}
public class Dog extends Animal implements Livable,Pat {
// 多实现的格式:class 类名 [extends 父类名] implements 接口1,接口2...{}
// 必须重写接口中的抽象方法
// 默认方法可重写可不重写
@Override
public void shouyang() {
System.out.println("shouyang()");
}
@Override
public void show() {
System.out.println("show()");
}
@Override
public void method() {
System.out.println("Dog");
}
public void eat(){
System.out.println("吃狗粮");
}
}
public class DynamicTest {
public static void main(String[] args) {
// 多态形式
// Dog dog = new Dog();
// 格式: 父类类型 对象名 = new 子类对象
Animal dog = new Dog();
dog.eat();
Animal cat = new Cat();
cat.eat();
}
}
2.2 向上(下)转型
1.向上转型(范围扩大,转成更大类型)
默认的:多态本身是子类类型向父类类型转化的过程
格式:父类类型 对象名 = new 子类对象
int a = 100;
// 变成double类型
double b = a; // b = 100.00
Animal cat = new Cat();
cat.eat();
2.向下转型(范围变小,父类转成子类类型)
强制的
格式:子类类型 对象名 = (子类类型)new 父类对象
double a = 99.9;
int b = (int)a; //b=99
Animal cat = new Cat();
if (cat instanceof Animal){
Cat c = (Cat) cat;
c.eat();
}
3.转型异常(.ClassCastException)
Dog dog = (Dog) cat;
dog.eat();
4.案例
案例一:使用笔记本(鼠标,键盘)
public interface USB {
// 功能:开启,关闭
void open();//开启功能
void close();//关闭功能
}
public class KeyBoard implements USB{
//实现USB,输入功能
public void input(){
System.out.println("键盘输入");
}
@Override
public void open() {
System.out.println("键盘开启");
}
@Override
public void close() {
System.out.println("键盘关闭");
}
}
public class Mouse implements USB{
//实现USB,点击方法
public void click(){
System.out.println("鼠标点击");
}
@Override
public void open() {
System.out.println("鼠标开启");
}
@Override
public void close() {
System.out.println("鼠标关闭");
}
}
public class NoteBookComputer{
// 功能:运行,关机,使用USB
public void useUSB(USB usb){
//判断是否有USB
if(usb != null){
usb.open();
if(usb instanceof Mouse){
Mouse mouse = (Mouse) usb;
mouse.click();
}else if(usb instanceof KeyBoard){
KeyBoard keyboard = (KeyBoard) usb;
keyboard.input();
}
usb.close();
}
}
public void open() {
System.out.println("电脑运行");
}
public void close() {
System.out.println("电脑关机");
}
}
public class NoteBookComputerTest {
public static void main(String[] args) {
NoteBookComputer noteBookComputer = new NoteBookComputer();
//开启
noteBookComputer.open();
//使用鼠标
USB mouse = new Mouse();
noteBookComputer.useUSB(mouse);
//使用键盘
USB keyBoard = new KeyBoard();
noteBookComputer.useUSB(keyBoard);
// 笔记本关闭
noteBookComputer.close();
}
}
案例二:
public interface Universe {
void doAnything();
}
public class Star {
public void shine(){
System.out.println("star:星星一闪一闪亮晶晶");
}
}
public class Sun extends Star implements Universe{
@Override
public void doAnything() {
System.out.println("sun:太阳吸引着九大行星旋转");
}
@Override
public void shine() {
System.out.println("sun:光照八分钟,到达地球");
}
}
public class Test {
public static void main(String[] args) {
Star star = new Star();
star.shine();
System.out.println("==============");
Universe sun = new Sun();
sun.doAnything();
Sun star1 = (Sun)sun;
star1.shine();
}
}
3 final
- 开放扩展,关闭修改
-
用于修饰不可改变的内容
3.1 修饰
1.类
//目的是仅限使用,不允许修改
final class 类名{}
2.方法
修饰符 final 返回值类型 方法名(参数列表){}
3.变量
- 基本数据类型
public class FinalDemo1 {
public static void main(String[] args) {
//声明一个变量,使用final修饰
final int a;
a = 10;
System.out.println(a);
/*报错不可重新赋值
a = 11;
*/
}
}
- 引用类型的局部变量
被final修饰,只能指向一个对象,地址值是不能改变的,但是不影响对象内部成员变量值的修改
final User user1 = new User();//User1的地址值不能改变 ox666
user1 = new User(); //报错
- 成员变量
//显示初始化
final String USERNAME = "张三";
//构造方法初始化
public class UserF2 {
final String USERNAME;
private int age;
public UserF2(String username,int age) {
this.USERNAME = username;
this.age = age;
}
}
4 权限修饰符
权限使用建议:
- 成员变量使用private,隐藏细节
- 构造方法使用public方便创建对象
- 成员方法用public方便调用方法
- 符合JavaBean规范