java三大特性的优点

java的三大特性（封装，继承，多态）

1.封装： 面向对象程式设计中，封装（Encapsulation）就是把类的内部与外界隔离起来，把实现数据和方法的包装（隐藏），防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据，必须通过特定的方式。
2.继承：继承是所有OOP语言和Java语言不可缺少的部分。当创建一个类时，总是在继承，除非已经明确声明继承某个类，不然默认继承Java的标准根类Object。

    继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

3.多态 ：多态的体现主要有两个方面：1、方法的重载和重写。2、对象的多态性。

计算机思维的例子

package com.demo.test;

import java.util.Scanner;

/**
 * 实现计算机计算器功能  输入两个数 numA numB 和运算符（+,-,*,/）
 * 缺点：1.面向客户的代码和业务实现的方法融合在一起
 * 不符合java的封装特性
 * 2.不利于拓展，如果我想增加运算，就必须修改代码
 * 3.代码不可复用，如果想使用只能通过复制粘贴
 * @author ADMIN
 *
 */
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//按照计算机思维的话就是，获取数字，然后获取运算符，计算出结果
		try {
			Scanner scan=new Scanner(System.in);
			System.out.println("请输入参数A:");
			int numA=Integer.parseInt(scan.nextLine());
			System.out.println("请输入参数B:");
			int numB=Integer.parseInt(scan.nextLine());
			System.out.println("请输入参运算符:");
			String operaStr=scan.nextLine();
			int sum = 0;
			switch (operaStr) {
			case "+":
				sum=numA+numB;
				break;
			case "-":
				sum=numA-numB;
				break;
			case "*":
				sum=numA*numB;
				break;
			case "/":
				if(numB==0) throw new Exception("被除数不能为0");
				sum=numA/numB;
				break;
			default:
				break;
			}
			System.out.println("计算结果："+sum);
		}catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
			System.out.println("请检查输入");
		}
//		System.out.println(a);
	}

}

加入封装的理念之后

Operation.java

package com.demo.test.fengzhuang;

public class Operation {
	public Integer getResult(int numA,int numB,String operaStr) throws Exception {
		int sum = 0;
		try {
			switch (operaStr) {
			case "+":
				sum=numA+numB;
				break;
			case "-":
				sum=numA-numB;
				break;
			case "*":
				sum=numA*numB;
				break;
			case "/":
				if(numB==0) throw new Exception("被除数不能为0");
				sum=numA/numB;
				break;
			default:
				break;
			}
		}catch (Exception e) {
			// TODO: handle exception
			throw new Exception("请检查输入参数");
		}
		
		return sum;
	}
}

Main.java

package com.demo.test.fengzhuang;

import java.util.Scanner;

/**
 * 前面说了代码没有使用到封装，这里使用封装
 * 先说下封装的好处，
 * 1.界面逻辑和实现逻辑分离
 * 2.代码可复用   
 * 3.增加界面罗杰和增加实现逻辑分离不会相互影响
 * 不用继承缺点
 * 1.使用封装之后，虽然具备了可复用的特性，但是如果我扩增方法的时候，却会看到加减乘除的方法实现，能不能扩展的时候只关注自己的方法，而不用
 * 担心误操作影响到别的方法呢
 * 使用继承之后
 * 1.扩展简单
 * @author ADMIN
 *
 */
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan=new Scanner(System.in);
		System.out.println("请输入参数A:");
		int numA=Integer.parseInt(scan.nextLine());
		System.out.println("请输入参数B:");
		int numB=Integer.parseInt(scan.nextLine());
		System.out.println("请输入参运算符:");
		String operaStr=scan.nextLine();
		Operation opr=new Operation();
		try {
			int num=opr.getResult(numA, numB, operaStr);
			System.out.println("计算结果:"+num);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println(e.getMessage());
		}
	}

}

加入继承和多态之后

Operation.java

package com.demo.test.jicheng;

public class Operation {
	/**
	 * 获取数据
	 */
	protected int numA,numB;
	public Operation(int numA,int numB) {
		this.numB=numB;
		this.numA=numA;
	}
	public int getResult() {
		int sum=0;
		return 0;
	}
}

oprAdd.java

package com.demo.test.jicheng;

public class oprAdd extends Operation{

	public oprAdd(int numA, int numB) {
		super(numA, numB);
		// TODO Auto-generated constructor stub
	}
	@Override
	public int getResult() {
		return numA+numB;
	}

}

oprJian.java

package com.demo.test.jicheng;

public class oprJian extends Operation{

	public oprJian(int numA, int numB) {
		super(numA, numB);
		// TODO Auto-generated constructor stub
	}
	@Override
	public int getResult() {
		return numA-numB;
	}
}

OprSelect.java

package com.demo.test.jicheng;

public class OprSelect {
	public int getResult(int numA,int numB,String oprStr) {
		int sum=0;
		switch (oprStr) {
		case "+":
			sum=new oprAdd(numA,numB).getResult();
			break;
		case "-":
			sum=new oprJian(numA,numB).getResult();
			break;
		default:
			break;
		}
		return sum;
	}
}

Main.java

package com.demo.test.jicheng;

import java.util.Scanner;

/**
 * 使用继承的方式来完成计算器，就要考虑区分父类和基类以及判断什么时候使用是那种方法，这里还有堕胎
 * 多态的体现主要有两个方面：1、方法的重载和重写。2、对象的多态性
 * 
 * @author ADMIN
 *
 */
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner scan=new Scanner(System.in);
		System.out.println("请输入参数A:");
		int numA=Integer.parseInt(scan.nextLine());
		System.out.println("请输入参数B:");
		int numB=Integer.parseInt(scan.nextLine());
		System.out.println("请输入参运算符:");
		String operaStr=scan.nextLine();
		int sym=new OprSelect().getResult(numA, numB, operaStr);
		System.out.println("运算结果是:"+sym);
	}

}