讲完了面向对象思想，我们需要用大量的代码来去真正的理解它
希望各位看我博客的初学者：先试着自己写。熬一阵子，再看代码。跟着代码去写
题目一、模拟实现一个计算器：
//做任何的代码设计不要马上投入编写
//先思考思考，写完后一点点慢慢改进，这样训练之下你的代码慢慢的，写出来无论代码规范还是耦合性都是尽可能最优良的
//一个计算机不能是算完一次后你就得重启，所以你的
//首先我们先设置4大加减乘除方法
public class Computer {
//设计一个方法前第一步 它是否有参数、第二部判断是否需要返回值，返回值是什么类型。
//然后再整体设计整个方法块，方法的返回值用return 关键字来处理
//注意：return关键字一旦执行到这里，整个方法会强制结束。
//所以在未来开发里用到线程或者死循环的一些方法有时候会用return 强制结束
//四大方法 + - 乘除
public float add(float a, float b){
return a+b;
}
public float sub(float a, float b){
return a-b;
}
public float mut(float a, float b){
return a*b;
}
public float chu(float a, float b){
return a/b;
}
//可以一直计算 //程序执行完了就over//通过某种途径让程序一直执行---》死循环
//期间通过读取到某些特地的字符让代码停止
//死循环
public void computlar(){
Scanner input =new Scanner(System.in);
System.out.println("请输入第一个数字");
float a = Float.parseFloat(input.nextLine());
//其实这一步把输入第一个数字放到循环之外，一是我们之后死循环不会再需要第一个数字二是那它做一个容器存储结果
while (true){
//Float.parseFloat 这个Float 的静态方法：参数一个sting，返回是：强制类型转换后的float 的值
System.out.println("请输入符号");
String sym =input.nextLine();
//等会加一个判断，如果 是某个特定字符，就让程序停止执行//一个撤销指令
System.out.println("请输入第二个数字");
float b= Float.parseFloat(input.nextLine());
//如果 是* 就调用mut方法
if(sym.equals("=")){//这里不用==是因为，equals是判断内容是否一样，==是判断对象地址是否一样
System.out.println("再见");
break;
}
switch(sym){
case "+":
a=this.add(a,b);//this 表示调用这个方法的对象，只有computer这个对象 this.add ==== computer.add
break;
case "-":
a=this.sub(a,b);
break;
case "*":
a=this.mut(a,b);
break;
case"/":
a=this.chu(a,b);
break;
}
System.out.println(a);
}
// 我们用户有一个需求：需要一直处理得到的结果
}
}
题目二：多态的理解（策略模式初识）：
//多态真的很重要很重要很重要，他让一组代码变得非常灵活，一定程度上让他能执行的所有类型对象。它也是封装框架工具中肯定是最常用的思想
//了解多态之前你要清楚的了解继承思想以及方法重写
//下面我通过多态模拟各类人去商店的行为。
//记住多态的最大特性父类的引用指向子类对象，能调用父类属性方法，以及子类重写的方法。
public abstract class Person {
public String name;
public abstract void eat();
}
public class PoorMan extends Person {
@Override
public void eat() {
System.out.println("Poorman买了三明治");
}
}
public class RichMan extends Person {
@Override
public void eat() {
System.out.println("Richman买了三文鱼");
}
}
public class TextMain {
public static void main (String []args){
Person person= new PoorMan();
//Person person =new RichMan();
person.eat();
}
}
//第一次执行的是PoorMan的方法
//第二次执行Richman
//这里，其实你执行的是同一方法，但因为放进去的对象不同（也叫做册罗）导致了输出不同，这就是策略模式的简单效果
接下来就是方法间互相调用，好好理解，从Arraylist封装开始将其，虽然只涉及一个类，对初学者来讲以及很困难了
public class ArrayBox {
//描述事物
//属性
//方法
//构造方法
//需要方法，用来添加元素，。
//确定容量方法
//扩容
//计算
private static final int DEFAULT_INITIALCAP=10;//默认数组长度
private int [] elementData;//一个底层真实存储数组
private int size=0;//描述array 实际有效长度
public ArrayBox (){
elementData=new int[DEFAULT_INITIALCAP];
}
public ArrayBox(int num){
elementData=new int [num];
}
//增加元素
public boolean add(int element){
//首先先确定现在的容器是不是已经满了
this.ensureCapcity(size+1);
elementData[size++]=element;
return true;
}
//集群增加
public boolean addAll(ArrayBox box){
//不能调用方法，性能太慢，直接操作内部的数组，
//1.确定量
// 2.拿到有效size,从size位开始
this.ensureCapcity(box.length());
//用方法把它变成数组
int [] resource =box.toArray();//这个是最能体现面向对象思想的一步，我自己到这里也楞了下，
for(int i=size;i<size+resource.length;i++){
elementData[i]=resource[i-size];
}
size+=resource.length;
//这时候 容量肯定是够的
//从size 位开始进行遍历赋值
//调用内部的遍历赋值方法？？？
return true;
}
//根据index位置删除元素//为了安全起见删除元素时候要
public int remove(int index){
//先看看这个index 是不是超过了范围如果超过，就抛出异常
//原码需要调用的虚拟机的一个方法实现复制
//那个点设置为空
this.ensureSize(index);
//开始删除
// 1 2 0 3 4 5
int reslut = elementData[index];
for(int i=index;i<size;i++){
elementData[index]=elementData[index+1];
}
elementData[size]=0;
size--;
return reslut;
}
//在特定位置set一个值
public int set(int index,int element){
this.ensureSize(index);
int result=elementData[index];
elementData[index]=element;
return result;
}
//查看元素（根据位置索引进行查看）
public int get(int index){
this.ensureSize(index);
return elementData[index];
}
//删除
//一种是跟
//box得到所有的值
public int [] getAll(){
return this.copyOf(elementData,size);
}
//得到某个特定值的位置
public int indexOf(Integer element){
int index =0;
for(int i=0;i<size;i++){
if(element.equals(elementData[i])){
index=i;
return index;
}
}
return -1;
}
public boolean contains(int element){
return this.indexOf(element)>=0;
}
public int length(){
return elementData.length;
}
//------------------------------------
//以下都是内部方法，我不想让用户看到
private boolean ensureSize(int index){
if(index>size || index ==size){
throw new ArrayIndexOutOfBoundsException("index:"+index+",size"+size);
//这部分就有点朝纲，其实我是自定义一个类，让他继承异常，写它的构造方法是调用父类异常的构造构造方法，异常构造方法会输出你的msg
}
return true;
}
private void ensureCapcity(int NewSize){
//新的玩意如果大于我就需要找人帮我算一下新建数组的大小
if(NewSize> elementData.length){
this.anyliseNewCapicaty(NewSize);
}
}
//分析要扩容多少
private void anyliseNewCapicaty(int NewSize){
int newCapacity= (elementData.length << 1)+elementData.length;//为什么不用size，不用
if(NewSize>newCapacity){
newCapacity=NewSize;
}
this.extendCapacity(newCapacity);
}
//扩容
private void extendCapacity(int newCapacity){
int [] newElementData =new int [newCapacity];
this.copyOf(size,newElementData);
}
//复制
private void copyOf(int size,int [] newElementData){
for(int i=0;i<elementData.length;i++){
newElementData[i]=elementData[i];
}
elementData=newElementData;
}
//toArray数据变成数组
private int [] toArray(){
//不能直接赋值过去 因为：1 2 3 0 0 0
return this.copyOf(elementData,size);
}
//用来负责返回的方法
private int [] copyOf(int [] elementData,int size){
int []newElementData = new int[size];
for(int i=0;i<size;i++){
newElementData[i]=elementData[i];
}
return newElementData;
}
public class ArrayIndexOutOfBoundsException extends RuntimeException {
public ArrayIndexOutOfBoundsException(){
}
public ArrayIndexOutOfBoundsException(String msg){
super(msg);
}
}
//自定义一个异常
原创文章 8
获赞 0
访问量 766