Java学习第三十四天＜Final＞＜抽象类＞<接口入门><接口与继承对比><接口数组><接口多态>
Final
package chapter10.D4关键字Final;
//final最后的，用在类则不能被继承（但可实例化），用在方法则不能被重写（可在子类继承），用在属性上则不能修改
//用作常量，必须赋值（定义时，构造器赋值，代码块赋值） 若是静态常量，不能用构造器赋值，因为加载顺序有先后
//final用在类上（希望不被继承），则没必要将方法也final（希望不被重写，继承不了当然重写不了）
//final与static常一起用，不会导致类加载
//String 和包装类（Double,Float,Integer,Boolean）都是final类，不能继承
public class Final {
public static void main(String[] args) {
System.out.println(B02.num);
}
}
class B02{
public final static int num=1000;
static {
System.out.println("BBB代码块执行");
}
}
package chapter10.D4关键字Final;
public class Fnialexercise {
public static void main(String[] args) {
Circle circle = new Circle(5.0);
System.out.println(circle.calArea());
}
}
class Circle{
private double radius;
private final double PI;//可直接赋值
public Circle(double radius) {
this.radius = radius;
//PI=3.14;构造器里赋值
}
{
PI=3.14;//代码块里赋值
}
public double calArea(){
return PI*radius*radius;
}
}
抽象类
package chapter10.D5抽象类;
//没有方法体，方法和类都要戴abstract，抽象类不能实例化，由子类继承实现
//abstract不能修饰属性和其他
//抽象方法不能使用private、final和static修饰 这些关键字和重写相违背（private不能重写，final不能被继承重写，static与重写无关）
public class Abstract01 {
public static void main(String[] args) {
new CommonEmployee("xx",1,200).work();
new Manager("yy",2,300,1000).work();
}
}
abstract class Employee{
private String name;
private int ID;
private double salary;
public Employee(String name, int ID, double salary) {
this.name = name;
this.ID = ID;
this.salary = salary;
}
public String getName() {
return name;
}
public int getID() {
return ID;
}
public double getSalary() {
return salary;
}
abstract public void work();
}
class CommonEmployee extends Employee{
public CommonEmployee(String name, int ID, double salary) {
super(name, ID, salary);
}
@Override
public void work() {
System.out.println("普通员工\t"+getName()+"\t工作中");
}
}
class Manager extends Employee{
private double bonus;
public Manager(String name, int ID, double salary, double bonus) {
super(name, ID, salary);
this.bonus = bonus;
}
@Override
public void work() {
System.out.println("经理\t"+getName()+"\t工作中");
}
}
package chapter10.D5抽象类;
//抽象类，模板设计模式
abstract public class Template {
public abstract void job();
public void calc(){//可做成模板
long start=System.currentTimeMillis();
job();
long end=System.currentTimeMillis();
System.out.println("执行时间"+(end-start));
}
}
class A02 extends Template{
@Override
public void job() {
long num=1;
for (int i = 0; i <=800 ; i++) {
num*=i;
}
}
}
class B02 extends Template{
@Override
public void job() {
long num=0;
for (int i = 0; i <=800000 ; i++) {
num+=i;
}
}
}
package chapter10.D5抽象类;
public class TestTemplate {
public static void main(String[] args) {
new B01().calc();
new A01().calc();
new A02().calc();
new A01().calc();
}
}
class A01{
public void calc(){//可做成模板
long start=System.currentTimeMillis();
job();
long end=System.currentTimeMillis();
System.out.println("执行时间"+(end-start));
}
public void job(){
long num=1;
for (int i = 0; i <=800 ; i++) {
num*=i;
}
}
}
class B01{
public void calc(){
long start=System.currentTimeMillis();
job();
long end=System.currentTimeMillis();
System.out.println("执行时间"+(end-start));
}
public void job(){
long num=0;
for (int i = 0; i <=800000 ; i++) {
num+=i;
}
}
}
接口入门
接口1
package chapter10.D6接口.Interface01;
//接口中所有方法都是public，故不用写修饰符，且默认抽象，不用abstract
public interface Usbinterface {
public void start();//规定接口相关方法
public void stop();
}
package chapter10.D6接口.Interface01;
public class Camera implements Usbinterface{
@Override
public void start() {
System.out.println("相机开始工作");
}
@Override
public void stop() {
System.out.println("相机停止工作");
}
}
package chapter10.D6接口.Interface01;
//Phone类实现USB接口（实现Usbinterface规定/声明的方法，重写）
public class Phone implements Usbinterface{
@Override
public void start() {
System.out.println("手机开始工作");
}
@Override
public void stop() {
System.out.println("手机停止工作");
}
}
package chapter10.D6接口.Interface01;
//带接口的主机工作，驱动其他设备
public class Computer {
public void work(Usbinterface u){//可传递实现接口的对象
u.start();//通过接口调用方法
u.stop();
}
}
package chapter10.D6接口.Interface01;
public class Interface01 {
public static void main(String[] args) {
Usbinterface camera = new Camera();//可向上转型
Phone phone = new Phone();
Computer computer = new Computer();
computer.work(phone);//手机接入到电脑
computer.work(camera);
}
}
接口2
package chapter10.D6接口.Interface02;
public interface In02 {
//写属性和方法
public int n1=10;
public void hi();//默认抽象
default public void ok(){//在jdk8后可以有默认实现方法，需default关键字修饰，或静态方法
System.out.println("ok...");
}
public static void cry(){
System.out.println("cry...");
}
}
package chapter10.D6接口.Interface02;
public class Interface02 {
public static void main(String[] args) {
new A().hi();
}
}
class A implements In02{
//要把该接口所有抽象方法实现，除非是抽象类
@Override
public void hi() {
System.out.println("hi....");
}
}
接口3
package chapter10.D6接口.Interface03;
public interface In03 {//项目经理
public void connect();
public void close();
}
package chapter10.D6接口.Interface03;
//A程序员，连接MysqlDB
public class MysqlDB implements In03{
@Override
public void connect() {
System.out.println("连接mysql");
}
@Override
public void close() {
System.out.println("关闭musql");
}
}
package chapter10.D6接口.Interface03;
//B程序员，连接OracleDB
public class OracleDB implements In03{
@Override
public void connect() {
System.out.println("连接OracleDB");
}
@Override
public void close() {
System.out.println("关闭OracleDB");
}
}
package chapter10.D6接口.Interface03;
public class Interface03 {
public static void main(String[] args) {
MysqlDB mysqlDB = new MysqlDB();
t(mysqlDB);//静态对象不用再创建对象
OracleDB oracleDB = new OracleDB();
t(oracleDB);
}
public static void t(In03 i){
i.connect();
i.close();
}
}
接口4
package chapter10.D6接口.Interface04;
public class Interface04 {
public static void main(String[] args) {
System.out.println(IB.n1);//证明静态属性
//B.n1=20 报错证明是final属性
}
}
interface IB{
void hi();
public static final int n1=100; //默认public static final修饰符
}
interface IC{
void say();
}
interface ID extends IB,IC{//接口不能再接其他接口，但可继承多个其他接口
}
class P implements IB,IC{//一个类可同时实现多接口
@Override
public void hi() {
}
@Override
public void say() {
}
}
接口与继承对比
package chapter10.D6接口.ExtendsVsInterface;
//继承拥有父类的功能，接口扩展其他类功能，接口是对单继承的补充
public class ExtendsVsInterface {
public static void main(String[] args) {
LittleMonkey xx = new LittleMonkey("悟空");
xx.climbing();
xx.swimming();
xx.flying();
}
}
class Monkry{
private String name;
public Monkry(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void climbing(){
System.out.println(getName()+"会爬树....");
}
}
class LittleMonkey extends Monkry implements Fishable,Birdable{//单继承，多接口
public LittleMonkey(String name) {
super(name);
}
@Override
public void swimming() {
System.out.println(getName()+"通过学习，可以像鱼儿一样游泳了");
}
@Override
public void flying() {
System.out.println(getName()+"通过学习，可以像鸟儿一样飞翔了");
}
}
interface Fishable{
void swimming();
}
interface Birdable{
void flying();
}
接口数组
package chapter10.D6接口.InterfaceArray;
public class InterfaceArray {
public static void main(String[] args) {
Usb[] usbs=new Usb[2];
usbs[0]=new P();
usbs[1]=new C();
for (int i = 0; i < usbs.length ; i++) {
usbs[i].work();
if (usbs[i] instanceof P){//判断运行类型
((P) usbs[i]).call();
}
}
}
}
interface Usb{
void work();
}
class P implements Usb{
public void call(){
System.out.println("手机可打电话");
}
@Override
public void work() {
System.out.println("手机工作中");
}
}
class C implements Usb{
@Override
public void work() {
System.out.println("相机工作中");
}
}
接口多态
package chapter10.D6接口.InterfacePolyPass;
//演示多态传递
public class InterfacePolyPass {
public static void main(String[] args) {
IG ig=new Teacher();//向上转型
IH ih=new Teacher();
ih.hi();
}
}
interface IH{
void hi();
}
interface IG extends IH{
}
class Teacher implements IG{
@Override
public void hi() {
System.out.println("hi");
}
}
浙公网安备 33010602011771号