多态:
多态：
1要有继承
2要有重写
3父类引用指向子类对象
重载（overLoad）
重写（overrRitr）
重载(overLoad):方法名相同，参数不同
可以分为:构造器重载和方法重载
好处:
1.一种访问接口，多个实现方法
2.实现多态调用
示例:构造器重载
public class Pointer{
int x,y;
public Pointer(){}
public Pointer(int x, int y){
this.x = x;
this.y = y;
}
}
示例:方法重载
public class MyTools{
public int sum(int x, int y){return x+y;}
public int sum(int... nums){
int rs = 0;
for(int n : nums){
rs += n;
}
return rs;
}
}
示例:
class A{
public void fun(){
}
}
class B extends A{
public void fun(int x){
}
}
B b = new B();
b对象有两种访问方法(重载)
b.fun()
b.fun(int)
重写(overRide):子类中覆盖父类中同名方法的实现，方法的返回值类型，方法名,参数都一样,子类中方法访问修饰符必须大于等于父类的方法的访问修饰符。
示例:
class A{
public void fun(){
System.out.println("这是A类中的fun()方法");
}
protected void fun2(){
}
}
class B extends A{
public void fun(){
System.out.println("这是B类中的fun()方法");
}
protected void fun2(){
}
或
public void fun2(){
}
}
final 最终的 关键字
修饰符,可以修饰类，属性，方法,不能修饰构造器
public final class A{//修饰类,终态类:不能作为父类，不能有子类
int x;
final int y;//修饰属性：只能赋一次值,不能修改
public static final int Z=10;//一般用法，表示常量
void fun1(){}
final void fun2(){}//修饰方法:子类不能重写该方法
}
常量:声明常量使用三个修饰符:public static final,常量名全部大写,有别于变量名。
常量的访问方法:类名.常量名,例如:A.Z
final关键字
修饰符,可以修饰类，方法，不能修饰属性，构造器
abstract 与 final不能同时并存
abstract 抽象的 关键字
public abstract class A{//修饰类:抽象类,不能实例化对象,但可以有构造器.
void fun1(){
//有方法体，有实现
}
abstract void fun2();
//修饰方法:抽象方法，不能有代码的实现部
}
抽象类:
抽象方法
abstract
他不实现，不需要用，子类要实现，必须要有子类重写
1.不能实例化对象，也就是不能new对象
2.抽象类中可以有具体方法，也可以包含抽象方法。
3.如果一个类中有抽象方法，这个类必须是抽象类。
4.抽象类一般作为父类.
java程序设计四大原则:
开闭原则:源代码开放，对修改关闭。
单一职则:业务逻辑与业务实体数据分离。
里氏替换:参数能用父类不用子类。
v1.0计算器
import java.util.*; public class Clac{ public static void main(String[] args){ Scanner kb = new Scanner(System.in); System.out.print("请输入第一个操作数:"); int num1 = kb.nextInt(); System.out.print("请输入第二个操作数:"); int num2 = kb.nextInt(); System.out.print("请输入第一个运算符:"); String op = kb.next(); int rs=0; if(op.equals("+")) rs = num1+num2; else if(op.equals("-")) rs = num1-num2; else if(op.equals("*")) rs = num1*num2; else if(op.equals("/")) rs = num1/num2; System.out.println("结果是:"+rs); } }
v2.0计算器
public class Calculation{ private int num1, num2; private String op; //业务实体 public void setNum1(int num1){ this.num1 = num1; } public void setNum2(int num2){ this.num2 = num2; } public void setOp(String op){ this.op = op; } //业务逻辑 public int getRs(){ if(op.equals("+")) return num1+num2; else if(op.equals("-")) return num1-num2; else if(op.equals("*")) return num1*num2; else if(op.equals("/")) return num1/num2; } } import java.util.*; public class App{ public static void main(String[] args){ Scanner kb = new Scanner(System.in); System.out.print("请输入第一个操作数:"); int num1 = kb.nextInt(); System.out.print("请输入第二个操作数:"); int num2 = kb.nextInt(); System.out.print("请输入第一个运算符:"); String op = kb.next(); Calculation c = new Calculation(); c.setNum1(num1); c.setNum2(num2); c.setOp(op); System.out.println("结果是:"+c.getRs()); } }
v3.0计算器
public abstract class Calc{ private int num1, num2,rs; private String op; public void setNum1(int num1){ this.num1 = num1; } public void setNum2(int num2){ this.num2 = num2; } public void setOp(String op){ this.op = op; } public int getRs(){ return rs; } public abstract void exec();//计算的抽象方法 } //加法器 public class Add extends Calc{ @Override public void exec(){ rs = num1+num2; } } //减法器 public class Diff extends Calc{ @Override public void exec(){ rs = num1-num2; } } //乘法 public class Mul extends Calc{ @Override public void exec(){ rs = num1*num2; } } ... //计算器的业务逻辑类 public class ClacBo{ public static Clac getCalc(String op){ Calc c = null; if(op.equals("+")) c = new Add(); else if(op.equals("-")) c = new Diff(); else if(op.equals("*")) c = new M(); //... return c; } }
import java.util.*; public class App{ public static void main(String[] args){ Scanner kb = new Scanner(System.in); System.out.print("请输入第一个操作数:"); int num1 = kb.nextInt(); System.out.print("请输入第二个操作数:"); int num2 = kb.nextInt(); System.out.print("请输入第一个运算符:"); String op = kb.next(); Calc c = ClacBo.getCalc(op); c.setNum1(num1); c.setNum2(num2); c.setOp(op); c.exec(); System.out.println("结果是:"+c.getRs()); } }