标签：jdk getter computer ima 创建对象 abs 为什么 nal 之间
抽象类抽象类abstract关键字
可以修饰方法：叫做抽象方法，没有方法体，需要使用分号表示声明结束，抽象方法所在的类必须是抽象类
子类必须重写父类的抽象方法，除非子类也是抽象类
抽象方法
使用abstract关键字修饰，只表示声明了一个方法，但是没有任何的实现
特点：
1）没有方法体，需要使用分号表示方法声明结束
2）如果一个类中有一个方法是抽象的，那么这个类必须是抽象的
3）抽象方法必须被子类重写，除非子类也是抽象类
抽象类特点
1）抽象类中可以包含抽象方法，也可以包含普通方法。
2）抽象类中有构造方法，但是不能创建对象，构造方法目的在子类中会被调用。
3）抽象类的存在就是为了被继承，子类必须重写父类的抽象方法，除非子类也是抽象类。
抽象类和普通类的区别
1）抽象类需要abstract，而普通类不需要
2）构造方法：都有，但是抽象类不能实例化对象，普通类可以
3）成员方法：抽象类中可以存在抽象的成员方法也可以存在非抽象成员方法，而普通类中只能存在非抽象成员方法
final和abstract是否可以连用
1）两个关键字修饰方法时，final修饰的方法特点：可以被继承不能被重写；abstract修饰的方法特点：必须被重写；所以这两个关键字不能同时修饰同一个方法
2）两个关键字修饰类时：final修饰的类特点：不能被继承；abstract修饰的类特点：必须被继承；所以这两个关键字不能同时修饰同一个类
综上所述：final和abstract不可以连用
final的类中能否有abstract方法？不能
abstract类中能否有final方法？可以
abstract的使用
package com.qf.day11;
/**
* 宠物类
*/
public abstract class Pet {
//编号
private int id;
//宠物昵称
private String name;
//健康值
private int health;
//亲密度
private int love;
//alt+/
public Pet() {
}
//alt+shift+s --》Generate constructor using field
public Pet(int id, String name, int health, int love) {
super();
this.id = id;
this.name = name;
this.health = health;
this.love = love;
}
//setter and getter
/**
* 抽象方法，没有方法体,
* 子类必须重写抽象方法
*/
public abstract void print();
//父类的吃的方法
public void eat() {
System.out.println("宠物吃东西");
int h=getHealth();
setHealth(h+2);
}
}
package com.qf.day11;
public class Dog extends Pet{
private String strain;
//setter and getter
public Dog() {
// TODO Auto-generated constructor stub
}
public Dog(int id, String name, int health, int love,String strain) {
super(id, name, health, love);
this.strain=strain;
}
@Override
public void print() {
System.out.println("狗狗信息：编号:"+super.getId()+" 昵称:"+super.getName()+" 健康值:"+getHealth()+" 亲密度:"+getLove()+" 品种:"+strain);
}
}
package com.qf.day11;
public class Test {
public static void main(String[] args) {
//Pet pet=new Pet();
Pet pet=new Dog(100,"大黄",100,90,"哈士奇");
pet.eat();
pet.print();
}
}
接口
接口的概念
从语法上讲：
接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有方法的实现。
从功能上讲：接口表示一种约定或能力
使用接口的好处
扩展类的功能,保持对外接口一致
接口实现了多重继承，完成类和任何实现接口子类的通信和交互
降低代码之间的耦合性
接口的特点
1）接口不能创建对象，而且接口中没有构造方法；
2）接口中的方法一般都是共有抽象方法：public abstract
3）接口中所有的属性都是共有静态常量属性：pulbic static final
在一个接口中声明方法时:
若没有声明访问权限，默认也是public，
若没其他修饰默认也是abstract；
声明属性时:
若没有声明访问权限和静态常量，默认也是public static final
语法
语法：
public interface 接口名{
//接口中的成员：抽象方法和静态常量
}
pulbic interface I{
public abstract void fun();
}
public class Impl implements I {
public void fun(){}
}
必须先继承再实现接口
public class Dog extends Animal implements I{
public void fun(){}
}
interface的实现与使用
package com.qf.day11_4;
public class Test {
public static void main(String[] args) {
Computer lenovo=new Computer();
Mouse luoji=new Mouse();
Upan jinshidui=new Upan();
Fan meidi=new Fan();
//通过接口把设备连接到电脑上
lenovo.usb1=luoji;
lenovo.usb2=jinshidui;
lenovo.usb3=meidi;
lenovo.work();
// USB usb=new Mouse();//向上转型
// USB usb2=new Upan();
// USB usb3=new Fan();
}
}
package com.qf.day11_4;
public class Computer {
//三个usb接口
USB usb1;
USB usb2;
USB usb3;
//运行
public void work() {
System.out.println("电脑启动成功");
if(usb1!=null) {
usb1.service();
}
if(usb2!=null) {
usb2.service();
}
if(usb3!=null) {
usb3.service();
}
}
}
package com.qf.day11_4;
public interface USB {
void service();//服务
}
package com.qf.day11_4;
public class Fan implements USB {
@Override
public void service() {
System.out.println("风扇和电脑连接成功，开始吹风.....");
}
}
package com.qf.day11_4;
/**
* 鼠标
*
*/
public class Mouse implements USB {
@Override
public void service() {
System.out.println("鼠标和电脑连接成功，开始工作....");
}
}
package com.qf.day11_4;
/**
* U盘
*
*/
public class Upan implements USB{
@Override
public void service() {
System.out.println("U盘和电脑连接成，开始传输数据");
}
}
接口中特殊的方法
1）jdk1.8之后接口中使用static关键字修饰的方法有方法体
2）jdk1.8之后接口中使用default关键字修饰的方法有方法体
package com.qf.day11_3;
/**
* USB接口
* 包含 抽象方法
* 常量
*
* 扩展：jdk 1.8
* 接口中可以包含 默认方法 和 静态方法
*/
public interface USB {
//抽象方法
//充电
public abstract void charge();
//传输数据
void transData();
//常量
int num=4;
//静态方法
public static void method1() {
}
//默认方法
public default void method2() {
}
}
面试题
接口和抽象类有什么区别?
语法:
1>抽象类使用abstract，接口使用interface
2>抽象类中可以包含抽象方法，也可以包含非抽象方法，接口中只能包含抽象方法和静态常量，jdk1.8之后接口可以包含静态方法和默认方法注意同时须有方法体。
3>抽象类和接口都不能实例化。
4>抽象类可以包含构造方法，接口中没有构造方法。
功能：
1>抽象类一般用来表示同类事物，接口可以表示不是同类事物。
2>抽象类可以实现代码的重用，也可以约束子类的功能。接口就是约束实现类的功能，降低代码之间的耦合性。
扩展面试题
int i=10;
i=i++;
System.out.println(i);
//输出i=10;
理解：i++看成是一个整体。
等价于 int k=i++;
i=k;
int k=0;
int i=10;
while(k<100){
i=i++; k++;
}
System.out.println(i);
//输出i=10;
标签：jdk getter computer ima 创建对象 abs 为什么 nal 之间
原文地址：https://blog.51cto.com/14819639/2502897
