a.累加求和思想:求1~100的和,求数组/集合中元素的和,求偶数的数,求总分
    int sum=0//循环外部定义sum变量,循环里面对每个元素累加
    
    for (; ; ) {
    //sum+=数据 
    }
    
    System.out.println(sum);
 
  b.计数器思想:折纸次数,水仙花个数
   int count=0;
   for (; ; ) {//这只是个结构
  //满足某些条件 count++
 
   }
   System.out.println(count);
   
 
  c.拆解逻辑思想:把大问题拆成小问题,每个小问题考虑用方法实现
    1.字符数组为了使用String类中的方法,把字符数组变成字符串
    2.已知文件中存在用户名,用户录入判断是否重复
      a.读取文件中的内容=>存储集合中
      b.拿着用户录入的用户名与集合中的用户名一一对比
        一旦发现重复,立马返回false,否则返回true
  
  d.重置标记思想
    1.已知容器中装满了数据,我们要在容器查找某个元素是否已经存在
    String[] str={"鱼翅","鲍鱼","海参","海胆"}
    String findStr="鲍鱼";//String findStr="海马"
   
    boolean flag=false;//为了区分找到和循环遍历完没找到的两种情况
    for (int i=0;i<str.length;i++ ) {
       if(str[i].equals(findStr)){
            flag=true;
             break;//找到之后直接停止查找
       }
    }
     if(flag){
     //一定找到
     }else{
     //没找到
     }
面向过程:强调的过程,步骤
 * 面向对象: 是一种思想,强调对象
 *
 *  在现实生活中:先有对象,类是我们人根据实物的特征分类
 *  在代码中:必须先有类,通过类可以创建无数个对象
 
 
 * this关键字:
 * 1.this 的作用:
 * 区分局部变量和成员变量同名的情况
 * this.xxx 那么这个xxx是成员变量
 * 没有this. 比如  name,那么这个是指局部变量
 *  2.this的本质
 *  this代表当前对象,就是this所在的方法,被谁调用,谁就是当前对象
 
 匿名对象:
 *   没有名字的对象,是指只创建对象 但是不用变量来接收
 * 匿名对象的特点:
 * 匿名也是一个对象,完全拥有对象的功能
 * 1.匿名对象.成员变量 = 10;
 * 2.syso(匿名对象.成员变量);
 * 3.匿名对象.方法名();
 *  缺点:一个匿名对象只能使用一次
 *
 *  当一个对象 我只想使用一次的时候,那么可以考虑用匿名对象
 
 方法的参数:可以是基本类型,也可以是引用类型
 * 如果方法参数是引用类型,那么调用方法时需要的是该引用类型的对象
 *
 * 举例子:杀孙猴子
 *
 * 方法的返回值:可以void 可以基本类型,也可以是引用类型
 * 如果方法的返回值是引用类型,那么调用方法 我们要返回的是该类的一个对象
 
 继承:java面向对象的是三大特性之一(封装,继承,多态)
 *
 封装:当代码多了,用方法封装,当方法多了,用类封装,当类多了,用包封装
 
 * 组合关系:
 * 当一个自定义类型A的成员变量的数据类型是自定义类型B时，A类与B类叫做组合关系。
 *
 * 举例: 家庭
 * public class Family{
 * private Person wife;
 * private Person Husband;
 * }
 *
 * 现实生活中的继承: 由孩子 继承  父辈的财产
 *
 * 代码中继承: 由 一个类(子类/派生类) 去继承另外一个类(父类/超类/基类)
 * 子类可以继承父类一切的可继承的属性和方法
 *
 * 继承的代码格式:
 * public class 子类名字  extends 父类名字{
 * //成员变量
 * //成员方法
 * }
 *
 * 举例: 员工类作为父类,他有三个子类(教师,助教,班主任)
 
 1.继承过程中 子父类成员变量的特点:
 * 通过子类对象访问成员变量时:
 * 如果这个成员变量子类有,那么优先访问子类自己的
 * 如果这个成员变量子类没有,那么再去方问父类继承下来的
 * 如果父类也没有,编译就报错
 *
 * 2.继承过程中 子父类成员方法的特点:
 * 成员方法的特点和上面的成员变量的特点是一样
 *
 * 总结:继承过程中 子父类成员变量/成员方法的特点:
 * 子类有用子类自己的,子类没有再去找父类,父类还没有编译报错
 
 java中类的设计原则:
 * 向上抽取共性原则
 *
 * 定义4个类:
 * 猫,狗,树,花
 
 继承中子类中出现与父类重名的成员变量
 *
 * 1.this:区分成员变量和局部变量同名时
 *
 * 2.super:只能在子类中使用,显示访问父类继承过来变量或者方法
 * 格式:super.变量名
 * super.方法名();
 * 作用:区分父类继承过来的成员变量 和 子类自己拥有的成员变量同名的情况
 
 继承中方法重写
 *
 * 1.方法的重载(overload):在一个类中,java允许方法名相同 但是参数列表必须不同
 * 参数列表必须不同:参数的个数,参数的类型,参数的顺序不同
 *
 * 2.方法的重写/覆写/覆盖(override):子类和父类中的方法的关系,子类出现了父类一模一样的方法
 
  总结以上案例:什么时候需要重写父类的方法?
 * 当子类发现父类的某一个方法,对于子类来说不适合,那么子类可以重写
 
  this.成员变量: 访问本类自己的成员变量
 * this.成员方法: 访问本类自己的成员方法
 *
 * super.成员变量:访问父类继承过来的成员变量
 * super.成员方法:访问父类继承过来的成员方法
 * super表示子类中父类继承过来的成员的标识.
 
 * 除了以上用法 还有下面的用法
 *
 * this();//this 的语句形式
 * 在本类内部,可以调用其他的构造
 * this(参数);//在本类内部调用其他构造
 *
 * 需求1,创建一个Dog的对象,要求:无论通过何种构造方法创建,Dog对象的年龄就是10岁.
 *
 * super();//super的语句形式
 * 在本类内部调用父类的构造
 * 子类所有的构造(无论有参数的 还是无参数的)都会默认第一行调用父类的无参数构造
 *
 * 为什么子类会默认调用父类的构造:面向对象设计的一个原则 单一职责原则
 * 一个类 不能太"累",只负责自己数据
 
 面向对象 开闭原则
 
 对修改关闭,对扩展开放.
 
 已经写好的功能模块(类),
 我们不建议修改,但是我们可以扩展.
 
 
 抽象类:含有抽象方法的类叫做抽象类
 * 抽象类是不能创建对象(java的规定)
 * 抽象类天生就是作为父类
 *
 * 抽象方法:一个方法不知道怎么去实现,那么我们可以不写方法体,还要在方法的前加上abstract修饰
 *
 *
 * 总结:一个子类 继承了抽象类, 那么必须重写抽象类中的所有抽象方法,然后才能创建对象
 * 否则,这个子类还是一个抽象类,不能创建对象
 *
 * 关于抽象类的注意事项:
 * 1.抽象类 中 一定有抽象方法吗?NO,如果一个类没有抽象方法,也可以是抽象类,但是不让我们创建该类的对象
 * 2.抽象类中是可以不定义抽象方法的，此时仅仅是不让该类创建对象，用于某些特殊的设计需要。
 * 3.设计时由具体类抽取出抽象类，而开发阶段应该先定义抽象父类，再根据不同需求由父类定义子类。
 
 
//子类继承了抽象类,会报错
//1.给本类加上abstract修饰
//2.重写那个抽象方法
 
面向对象使用:
 *   名词提炼法: 小明 在公交车上牵着一条嘴里叼着热狗的狗
 * 小明:人类
 * 公交车:车类
 * 热狗:食物类
 * 狗:动物/狗类
 *  案例: 士兵突击(标题党)
 * 一个士兵开枪打死了一个鬼子
 * 士兵: Soldier
 *  名字,等级
 *  方法:开枪
 * 枪:  Gun
 * 名称,颜色
 * 方法:发射子弹
 * 鬼子:Animal
 * 昵称
 * 方法:会死