oop

1.多态:多种形态

1)多态的意义:

1.1)同一类型的引用指向不同的对象时，有不同的实现
行为的多态: cut()，run()

1.2)同一个对象被造型为不同的类型时，有不同的功能
对象的多态: 我，水

2)向上造型:

2.1)父类型的引用指向子类的对象

2.2)能造型成的类型为:父类、实现的接口

2.3)能点出来什么，看引用的类型

3)强制类型转换，成功的条件:

3.1)引用所指向的对象，就是该类型

3.2)引用所指向的对象，实现了该接口

4)若违背如上两个条件，则发生类型转换异常ClassCastException
建议强转之前通过instanceof来判断是否是该类型
instanceof为true的条件就是强转成功的条件

package oopday06;

import java.util.Scanner;

public class UnionPayTest {
public static void main(String[] args) {
AbcAtm atm = new AbcAtm();
Unionpay card = new AbcImpl(5000,"123456");
atm.insertCard(card);
atm.allMenu();
}
}

//Abc ATM
class AbcAtm{
private Unionpay card;
//实现读卡功能
public void insertCard(Unionpay card){
if(card!=null){
this.card = card;
}
}
//实现取卡操作
public void outCard(){
card = null;
}
//实现查询余额功能
private void showBalance(){
System.out.println("当前余额是："+card.getBalance());
}
//实现取款功能
private void takeMoney(){
Scanner input = new Scanner(System.in);
System.out.println("请输入取款金额：");
double number = Double.parseDouble(input.next());
if(card.drawMoney(number)){
System.out.println("取款成功");
}else{
System.out.println("取款失败");
}
}
//实现交话费功能
public void payTelBill(){
Scanner input = new Scanner(System.in);
if(card instanceof Abc){
Abc abccard = (Abc)card;
System.out.println("请输入电话号码：");
String TelNum = input.next();
System.out.println("请输入金额：");
double sum = Double.parseDouble(input.next());
if(abccard.payTelBill(TelNum, sum)){
System.out.println("缴费成功");
}else{
System.out.println("缴费失败");
}
}else{
System.out.println("不是农行卡。");
}
}
//实现ATM的菜单功能
public void allMenu(){
Scanner input = new Scanner(System.in);
System.out.println("请输入密码：");
String pwd = input.next();
if(card.checkPwd(pwd)){
System.out.println("请选择功能：\n1.查询余额 2.取款 3.缴电话费");
int choice = Integer.parseInt(input.next());
switch(choice){
case 1:
showBalance();
break;
case 2:
takeMoney();
break;
case 3:
payTelBill();
break;
default :
System.out.println("非法输入");
}
}else{
System.out.println("密码错误");
}
this.outCard();
}
}

//银联接口
interface Unionpay{
public double getBalance();
public boolean drawMoney(double number);
public boolean checkPwd(String input);
}
//Ccb接口
interface Ccb extends Unionpay{
public void payGasBill(double number);
}

//Icbc接口
interface Icbc extends Unionpay{
public void payOnline(double number);
}
//Abc接口
interface Abc extends Unionpay{
public boolean payTelBill(String phoneNumber,double number);
}

//Ccb卡
class CcbImpl implements Ccb{
private double money;
private String pwd;

public CcbImpl(double money,String pwd){
this.money = money;
this.pwd = pwd;
}

@Override
public void payGasBill(double number) {
if(number<money){
money-=number;
}
}

@Override
public boolean checkPwd(String input) {
if(pwd.equals(input)){
return true;
}
return false;
}

@Override
public boolean drawMoney(double number) {
if(number<money){
money-=number;
return true;
}
return false;
}

@Override
public double getBalance() {

return money;
}

}

//Icbc卡
class IcbcImpl implements Icbc{
private double money;
private String pwd;

public IcbcImpl(double money,String pwd){
this.money = money;
this.pwd = pwd;
}

public boolean checkPwd(String input){
if(pwd.equals(input)){
return true;
}
return false;
}

public boolean drawMoney(double number){
if(number<=money){
money-=number;
return true;
}
return false;
}

public void payOnline(double number){
if(number<=money){
money-=number;
}
}

@Override
public double getBalance() {
return money;
}
}
//Abc卡
class AbcImpl implements Abc{
private double balance;
private String password;

public AbcImpl(double balance,String password){
this.balance = balance;
this.password = password;
}

@Override
public boolean checkPwd(String input) {
if(password.equals(input)){
return true;
}
return false;
}

@Override
public boolean drawMoney(double number) {
if((balance-number)>=-2000){
balance-=number;
return true;
}
return false;
}

@Override
public double getBalance() {

return balance;
}

@Override
public boolean payTelBill(String phoneNumber, double number) {
if( phoneNumber.length()==11 && (balance-number)>=-2000 ){
balance-=number;
System.out.println("支付成功");
return true;
}
return false;
}

}

2.成员内部类:

1)类中套类，里面的叫内部类，外面的叫外部类

2)内部类通常只服务于外部类，对外不具备可见性的

3)内部类对象通常只在外部类中创建

4)内部类中可以直接访问外部类的成员(包括私有的)
内部类中有一个隐式的引用指向创建它的外部类对象
外部类名.this.成员变量

package oopday06;

public class InnerClassDemo {
public static void main(String[] args) {
Mama m = new Mama();
//Baby b = new Baby();//编译错误，inner类对外不可见
}
}

class Mama{
private int ar=9;
Baby b = new Baby();
Baby createBaby(){
return new Baby();
}
class Baby{
void show(){
System.out.println(ar);
System.out.println(Mama.this.ar);
// System.out.println(this.ar);//编译错误，内部类不具有ar属性
}
}
}

3.匿名内部类:

1)想创建一个类的对象，对象创建后，类的意义就不存在了，
此时该类不必命名，称之为匿名内部类

package oopEx;

public class innerTest {
public static void main(String[] args) {
MyInner inner = new MyInner(){
public void show(){
System.out.println("123");
}
public void say(){
System.out.println("谢谢！");
}
};
inner.show();
inner.say();
}

}

interface MyInner{
public void show();
public void say();
}

2)匿名内部类中若想访问外部的变量，变量必须是final的

package oopday06;

public class NstInnerClassDemo {

public static void main(String[] args) {
Inter2 o1 = new Inter2(){
};
final int num = 250;
Inter3 o2 = new Inter3(){
public void show(){
System.out.println("123");
System.out.println(num);
}
};
o2.show();
}

}
interface Inter3{
public void show();
}

interface Inter2{

}

4.面向对象三大特点:

1)封装:

1.1)类:封装的是对象的属性和行为

1.2)方法:封装的是功能的具体的实现

1.3)访问修饰符:封装的是访问的权限

2)继承:

2.1)减少代码重复，有利于代码的重用

2.2)父类/基类:所有子类所共有的
子类/派生类:子类所特有的

2.3)一旦子类继承的父类，子具有:父+子

3)多态:

3.1)意义:行为的多态、对象的多态

3.2)向上造型、强制类型转换、instanceof

3.3)多态后，代码扩展性、维护性.....-----好

3.4)多态的表现形式:
重写与重载