面向对象介绍
面向对象引入
需求：求数组{1,2,3,4,8,7,6,5}的最大值；
 public static void main(String[] args) {
		// 需求：求数组{1,2,3,4,8,7,6,5}的最大值；
		/*
		 * 解决问题的思路： 1、明确需求：搞清楚、确认清楚，到底要我们做什么事； 2、需求分析：如何实现需求（这个事情到底该怎么做）；
		 * a:创建一个数组，把需求中的数据保存到数组中； b:定义一个int型变量max，表示最大的值；
		 * c:将数组中0下标的数据赋值该上一步的变量，表示默认0下标数据是最大值； d:从1下标开始遍历数组，拿到数组中每一个数据，和变量max的值比较；
		 * 如果变量max中的数据比数组某个下标的数据小，就把该下标的数据赋值给变量max； e：循环结束，变量max中就是要求的最大值
		 * 3、编码实现：具体开始做事情； 4、测试：执行代码，看看事情到底有没有做成、有没有问题；
		 */
		// a:创建一个数组，把需求中的数据保存到数组中；
                 int[] arr = new int[] {11,2,3,4,8,7,6,5};
		// b:定义一个int型变量max，表示最大的值；
                 int max;
		// c:将数组中0下标的数据赋值该上一步的变量，表示默认0下标数据是最大值；
		max = arr[0];
		// d:从1下标开始遍历数组，拿到数组中每一个数据，和变量max的值比较；
                 for (int i = 1; i < arr.length; i++) {
			// 	如果变量max中的数据比数组某个下标的数据小，就把该下标的数据赋值给变量max；
                  if(max < arr[i]) {
				max = arr[i];
			}
		}
		// e：循环结束，变量max中就是要求的最大值
		System.out.println("数组中最大值是：" + max);
	}
随着时间往后发展，可能在一个类中多次需要用到求数组最大值的功能。
如果每一次出现数组求最大值的功能，都像上面一样在写一遍代码，就很麻烦，而且代码复用性差，后期维护就难；
为了解决这个问题，我们可以使用函数来实现：
需求：有可能在不同的程序中都出现这个功能：求数组的最大值；
思考：如果可以将函数抽取出来，放到某一个地方，然后在提供一种方法，让所有需要使用这个函数的地方都可以调用这个函数，就能解决在不同的类中出现相同函数代码的问题；
因为函数是定义在类中的独立代码，所以要抽出来，也只能放到某一个类中；
问题：一个类中不能直接使用其他类的函数；如何解决这个问题？
解决办法：Java中通过 类名.函数名(实参) 的方式，可以调用其他类中的函数；
本类中：
方法放在了Tools.java这个类中；
在其他类中要想调用，应该这么写：
Tools.arrayMax(具体的数组);
像最后这种方式，就使用了面向对象的思想；
https://www.zhihu.com/video/1065593352904314880
面向过程
什么是过程：
过程就是做一件事情的先后经过；
生活中的过程：
泡面：1、买面；2、烧开水；3、拆包装，把面放到开水中，加入调料，盖上；4、吃面；
程序的过程：
java中的过程，程序执行的先后经过，先执行哪行，后执行哪行；
什么是面向过程：
就是一种解决问题的思想；
使用这种思想解决问题，我们关心的是事情中有哪几步组成， 然后一步步实现；
使用面向过程写程序，我们首先要分析需求由那些功能组成，然后写函数实现各个功能，最后根据需求依次调用各个函数；
在这个过程中，开发者需要参与到实现的每一步中，就是劳动者；
前面几天都是按照面向过程的思想写程序；
面向过程的好处：在需求简单的时候，程序简单明了，结构清晰；
弊端：在需求复杂的时候，就会非常麻烦，开发和维护都很困难；
面向对象
什么是对象：
指的是生活中实际存在的事物；
生活中的对象：
冰箱；被子；钱；电脑；手机；椅子；桌子；地板；电灯；空气；雾霾；地球；太阳；……
什么是面向对象：
也是一种解决问题的思想；
使用这种思想解决问题，我们关心的是事情中有那些参与者；
使用这种思想写程序，首先分析需求有那些功能，然后找有没有已经实现好功能的类，
如果有，就直接拿来，创建它的对象，通过对象调用功能；
如果没有，就需要自己写一个类，然后在类中书写实现功能的函数【面向过程】，然后创建这个类的对象，通过对象调用功能；
面向对象的思想，更符合我们现实生活情况，也更适合开发复杂的功能;
在面向过程中，程序的基本单位是函数；面向对象，程序的基本组成就是类；
https://www.zhihu.com/video/1065593911182999553
类与对象
类
类的概念
类：表示一类具有共同属性和行为的事物，是一种抽象的概念。
例如，生活中我们经常说的一个词，“电话”，指的就是所有具有打电话功能的东西，而不是指代具体某一部电话；
类的写法
在Java中采用class关键字定义类。定义类的格式：
修饰符  class   类名{
	类中的内容
}
修饰符：public、default(默认的)、private、static（内部类），如果省略不写，那就是默认的修饰符（default）。
类名：必须符合标识符的定义语法要求，同时还要满足如果是多个单词每个单词首字母大写。
类中的内容：主要根据类的描述信息进行具体的书写。后面详细讲解。
类的成员
一个类可以表示同一类事物的共有属性和功能；
事物的属性使用类中的变量表示，事物的功能使用类中的函数表示；
例如，创建一个类表示人：
class  Person{
年龄；
性别；
姓名；
地址；
……
吃饭
睡觉
说话
……

}
https://www.zhihu.com/video/1065594261700911104
对象
对象的概念
在现实生活中，对象指的是实际存在的事物；
在Java中，对象指的是在堆内存中开辟的一块空间；例如数组就是一个对象；
对象都是根据类创建出来的；
对象的创建
Java中对象的创建，有五种方式：
使用new关键字创建；
使用使用Class类的newInstance方法
使用Constructor类的newInstance方法
使用clone方法
使用反序列化
其中，最常用、最简单的方式，就是使用new关键字创建对象；
格式：
创建对象的方式：
new 类名();
对象的使用
通过对象名使用：
https://www.zhihu.com/video/1065594851201978368
类和对象的关系
类是抽象的概念，表示的是同一类事物共同的属性和行为；
事物的属性使用类中的成员变量表示，事物的行为使用类中的函数表示；
对象是根据类的描述在堆内存中开辟的一块空间，表示的是一个具体的事物；
对象是根据类创建的，先有类，后有对象。类是抽象的，对象是具体的；
https://www.zhihu.com/video/1065594978910318592
面向对象练习：
使用Java代码描述 猫抓老鼠的场景；
猫的名字叫汤姆，老鼠的名字叫杰瑞；
具体的场景输出应该是：
汤姆看见杰瑞在偷吃奶酪；
汤姆追杰瑞，杰瑞逃跑；
汤姆抓住杰瑞，杰瑞叫：啊，要死啦！
使用面向对象思想解决问题，
第一步：分析需求，找到对象；
找对象的方法：名词提炼法；就是观察需求描述的文字，找到里面的名词；名词表示的就是实际的事物，也就是对象；
分析可知，这个例子中，有三个对象：猫；老鼠；奶酪；
因为奶酪不参与其他活动，所以为了简单，这里就用一个字符串表示奶酪；
所以需要创建两个类，分别表示猫和老鼠；
第二步：使用伪代码描述上面找到的对象；
描述对象的原则：只需要描述和需求有关的属性和行为；
伪代码，就是不是真实的代码；就是程序员自己写的自己能看懂的符号，例如中文……
猫｛
    属性：名字；
    行为：	看见（老鼠）｛
    老鼠的吃（“奶酪”）；
｝
追（老鼠）｛
    老鼠的逃跑（）；
｝
抓住（老鼠）｛
   老鼠的叫（“啊，要死啦！”）；
｝
｝
老鼠｛
   属性：名字；
   行为：吃（奶酪）｛｝
   跑（）｛｝
   叫（叫的内容）｛｝
｝
第三步：使用伪代码描述场景：
猫  t = new 猫（）；
老鼠 l = new 老鼠（）；
t的名字 = “汤姆”；
l的名字 = “杰瑞”；
t.看见（l）；
t.追（l）；
t.抓住（l）；
第四步：书写代码：
表示猫的类：
/**
 * 
 * Cat
 * 表示猫的类
 * @author 快学大数据
 * 2018年6月14日 上午11:51:38
 */
public class Cat {
	String name;
	/**
	 * 猫看见老鼠的功能
	 * @param m
	 */
 public void see(Mouse m) {
		System.out.print(name + "看见");
		//老鼠在吃奶酪
		m.eat("奶酪");
	}
	/**
	 * 猫追老鼠的功能
	 * @param m
	 */
 public void zhui(Mouse m) {
		System.out.println(name + "开始追"+m.name);
		//调用老鼠对象的方法，表示老鼠在逃跑
		m.run();
	}
	/**
	 * 表示猫抓住老鼠的功能
	 * @param m
	 */
 public void catchMouse(Mouse m) {
		System.out.println(name + "抓住了"+m.name);
		//调用老鼠对象的方法，表示老鼠被抓住后的惨叫
		m.say("啊，要死啦！");
	}
}
表示老鼠的类：
/**
 * 
 * Mouse
 * 表示老鼠的类
 * @author 快学大数据
 * 2018年6月14日 上午11:52:26
 */
public class Mouse {
	String name;//老鼠的名字
	/**
	 * 老鼠吃东西的功能
	 * @param food
	 */
 public void eat(String food) {
		System.out.println(name + "在吃" + food);
	}
	/**
	 * 老鼠逃跑的功能
	 */
 public void run() {
		System.out.println(name + "正在疯狂的逃跑……");
	}
	/**
	 * 老鼠叫的功能
	 * @param str
	 */
 public void say(String str) {
		System.out.println(name + "大声的说："+str);
	}
}
模拟场景的类：
/**
 * 
 * Test
 * 测试猫抓老鼠的场景类
 * @author 快学大数据
 * 2018年6月14日 上午11:58:10
 */
public class Test {
 public static void main(String[] args) {
		//1、先创建一个猫对象
		Cat cat = new Cat();
		//2、给这个猫起个名字
		cat.name = "汤姆";
		//3、创建一个老鼠对象
		Mouse m = new Mouse();
		//4、给这个老鼠起个名字
		m.name = "杰瑞";
		//调用方法，输出场景要求
		cat.see(m);
		cat.zhui(m);
		cat.catchMouse(m);
	}
}
https://www.zhihu.com/video/1065595884678664192
局部变量和成员变量
局部位置：局部是指某个范围。例如：方法的大括号中的这些个范围，它就是一个局部范围。
成员位置：在定义好类之后，在类的大括号内部的范围。
局部变量没有默认值，使用之前必须先赋值；
成员变量的位置在堆内存，所以都有默认值，使用之前可以先不赋值；
生命周期（内存的声明周期就是指内存的分配到回收）：
局部变量：局部变量的内存在栈内存的方法里面，函数进栈开始分配空间；函数出栈内存被释放；
成员变量：成员变量在堆内存中；创建对象时分配内存；对象成为垃圾空间被回收时释放；
局部变量：在局部范围中定义的变量，它们全部属于局部变量，并且它的使用范围就在从定义的位置往下到范围结束。
成员变量：直接在类的成员位置上定义的变量。这些变量不受位置的限制，可以在任何方法中被使用。但是建议将所有的变量定义在类的最前面位置。
https://www.zhihu.com/video/1065596048357060608

给定一个整形数组，找出最大下标距离j−i, 当且A[i]<A[j]和i<j
复杂度：三次扫描，每次的复杂度O(N)
算法：{5,3,4,0,1,4,1}

找出从第一个元素开始的下降序列{5,3,0}
i=3,j=6, j从尾部扫描
初始化，i=3, j=6, A[i]=0
//HelloDate.java
import java.util.*;


public class MyDemo{

    public int maxIndexDistance(int[] A){
        if(A==null || A.length<2)
            return 0;
        boolean inDescSeq[]=new boolean[A.length];
        int min=A[0], n=A.length;
        inDescSeq [0]=true;
        for(int i=1;i<n;i++){
            if(A[i]<min){
                //下降序列的标记
                inDescSeq[i]=true;
                min=A[i];
            }
        }

        int maxDist=0,i=n-1,j=n-1;
        while(i>=0){
            if(inDescSeq[i]==false){
                i--; //倒叙找到下一个下降序列
                continue;
            }
            while((A[j]<=A[i])&& (j>i))
                j--; //从后往前移动，直至找到符合的元素
            if((j-i)>maxDist){
                maxDist=j-i;
            }
            i--;
        }
        return maxDist;

    }

     public static void main(String[] args) {
         MyDemo demo=new MyDemo();
         int[] test={5,2,4,0,1,4,1};
         int result=demo.maxIndexDistance(test);
         System.out.println(result);         

         }
     }




c++



//
//  main.cpp
//  testProject
//
//  Created by 健 米 on 16-4-25.
//  Copyright (c) 2016年 __MyCompanyName__. All rights reserved.
//

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
using namespace std;

class Solution{
public:
    int maxIndexDistance(int A[],int length){

        if(length<2)
            return 0;
        bool inDescSeq[length];
        int min=A[0],n=length;
        inDescSeq[0]=true;

        for(int i=1;i<n;i++){
            if(A[i]<min){
                //标记下降序列
                inDescSeq[i]=true;
                min=A[i];
            }

        }
        int maxDist=0,i=n-1,j=n-1;
        while(i>=0){
            if(inDescSeq[i]==false){
                i--;
                continue;
            }
            while((A[j]<=A[i]) && (j>i))
                j--;
            if((j-i) > maxDist)
                maxDist=j-i;
            i--;
        }

        return maxDist;

    }


};

int main (int argc, const char * argv[])
{
    Solution s;
    int test[]={5,2,4,0,1,4,1};
    int length=sizeof(test)/sizeof(int);

    int res=s.maxIndexDistance(test,length);
    cout<<res<<endl;

}



vector
//
//  main.cpp
//  testProject
//
//  Created by 健 米 on 16-4-25.
//  Copyright (c) 2016年 __MyCompanyName__. All rights reserved.
//

#include <iostream>
#include <vector>
#include <map>
#include <string>
#include <algorithm>
using namespace std;

class Solution{
public:
    int maxIndexDistance(vector<int> &nums){

        int length = nums.size();        
        if(length<2)
            return 0;
        bool inDescSeq[length];
        int min=nums[0],n=length;
        inDescSeq[0]=true;

        for(int i=1;i<n;i++){
            if(nums[i]<min){
                //标记下降序列
                inDescSeq[i]=true;
                min=nums[i];
            }

        }
        int maxDist=0,i=n-1,j=n-1;
        while(i>=0){
            if(inDescSeq[i]==false){
                i--;
                continue;
            }
            while((nums[j]<=nums[i]) && (j>i))
                j--;
            if((j-i) > maxDist)
                maxDist=j-i;
            i--;
        }

        return maxDist;

    }


};

int main (int argc, const char * argv[])
{
    Solution s;
    vector<int> test;
    int n,t;
    cin >> n;

    while(n--)
    {
        cin>>t;
        test.push_back(t);
    }

   // int length=test.size();

    int res=s.maxIndexDistance(test);
    cout<<res<<endl;

}

//选择排序
public class HomeWork2 {
	public static void main(String[] args) {
    	int[] arr = {1, 3, 2, 4, 9, 5, 67, 7, 5, 6};
    	//对数组重新排序
    	exchange(arr);
    	//遍历数组
    	for (int i = 0; i < arr.length; i++) {
    		System.out.print(arr[i] + " ");
		}
    	
	}
	/**
	 * 将数组按照从大到小的顺序排列
	 * 
	 * @param arr int类型数组
	 */
	public static void exchange(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			int index = i;
			int temp = 0;
			
			//比较最大的数将下标放在index,
			for (int j = i + 1; j < arr.length; j++) {			
				if (arr[index] < arr[j]) {
					index = j;					
				}		
			}
			
			//将找到的最大的数放在当前下标里
			temp = arr[i];	
			arr[i] = arr[index];
			arr[index] = temp;
		}
	}
}

在做一道java 习题时，遇到了求数组最大下标的问题，脑子里只有排序算法的思路，始终不得其解。
在网上搜索一番后得出答案。


具体思路是 设定一个最大下标变量，通过循环让数组中的每一个值依次与数组的最大下标值进行比较。从而得出最大下标值。
public static void getMaxIndex(int[] array){
int maxIndex=0;
for(int i=0;i<array.length;i++){
if(array[i]>array[maxIndex]){
maxIndex=i;
}
}
System.out.println(maxIndex);
}