今天做的事情：

               java基础：

              1  关于匿名对象：有时候只使用一次的对象，没必要声明并初始化操作。直接使用匿名对象。

class Student{
      public void tell(){
            System.out.println("hello 修真院");
    }
}

public class NiMing {

      public static void main(String[] args) {
      //正常情况
        Student s = new Student();
        s.tell();

        //匿名对象
        new Student().tell();

    }

              2.  类中的构造方法

               注意点： （1）：构造方法名称必须与类名一致

                              （2）：构造方法没有返回值

                              （3）：构造方法主要是为类中的属性初始化

                              （4）：每个类在实例化之后都会调用构造方法，如果没有，则编译时会创建。

                              （5）：构造方法也可以重载

class Person{

    private int age;
    private String name;

    public int getAge() {
            return age;
    }

      public void setAge(int age) {
             if(age>=0 && age <150){
                   this.age=age;
        }
    }

      //访问修饰符 + 类名
    public Person(int age ,String name){
            System.out.println("姓名："+name+" 年龄："+age);
    }


      //访问修饰符 + 类名
    public Person(int age ){
            System.out.println("年龄："+age);
    }
}

public class GouZaoMethod {

      public static void main(String[] args) {
             Person p = new Person(10,"小虎");
        System.out.println(p);
        p.setAge(-10);
        System.out.println(p.getAge());
    }

}

             在main里面，明明赋值为-10，显示为0。因为在set方法里面进行判断了，因为age为-10不符合逻辑。从出生是0开始。

             重载就是同名不同参。方法名可以相同，参数的个数和类型不同。这样方法名重复。

             上文中创建的Person类，在java内存中分别存储在 栈空间和堆空间。

             栈空间：先进后出，空间小，存储对象名引用

             堆空间：存储空间大，适合存储基本类型及数据。

              例如一个数组，数组名存在栈空间，数据都存在堆空间，使用时，用栈空间的数组名去堆空间找数据。

              3.   关于方法的递归调用

                     递归调用就是一种特殊的调用形式，方法自己调用自己，直到符合条件，结束。

public class Digui {

    public static int test(int i){

              if(i == 1){
                   return 1;
        }else{
                   return i+test(i-1);
        }
    }
      public static void main(String[] args) {
           System.out.println(test(10));
    }
    
}

                一个test方法，参数是int类型的 i ，在if判断，为1，则返回1，不为一。继续循环方法，直到 i -1 结果为1.

                 10 + 9 + 8 + 7 + 6 + 5 +4 + 3 + 2 +1 = ？

                  4. 继承

                在java中只有单继承，继承之后，是父类与子类的区别，子类可以调用父类的公共方法和属性，但是父类并不能调用子类的东西。而且在实例化子类的时候，会先实例化父类的构造方法，再实例化子类的构造方法。

class Father{

    public void tell(){
        System.out.println("父类方法tell");
    }

    public Father(){
        System.out.println("父类构造方法");
    }
}

class Son extends  Father{

    public void tell(){
        super.tell();
        System.out.println("子类重写父类的tell");
    }

    public Son(){
        System.out.println("子类构造方法");
    }
}


public class JiCheng {

    public static void main(String[] args) {
        Son s = new Son();
        s.tell();
    }

}

                 父类中有的属性，子类无需再次创建，就可以使用super关键字去使用即可，而super是强制使用父类的方法。

                  在继承中，也存在这重写的概念，就是子类定义与父类相同的方法名，特点：方法名，参数，参数类型，参数个数都一样。

                  还有一点，重写的限制，子类中不能比父类更严格的访问权限

                  例如父类的方法是public , 子类的不能是private及default。如果父类方法是default，子类可以是public,但是不能是private

                    private < default < public

                5.    final 关键字

                上面说的，继承，重写，已经了解过了，而这个final是影响这两个的使用。

                final关键字在java中被称为完结器，表示最终的意思。final能声明类，方法，属性、

                 》1  使用fanal声明的类，不能被继承

                 》2 使用final声明的方法，不能被重写

                 》3 使用final声明的变量为常量，不能更改。

                  6. 抽象类

                     1 抽象类就是：包含一个抽象方法的类。

                     2 抽象方法 ：声明而未被实现的方法，抽象方法必须使用abstract关键字声明。

                     3 抽象类被子类继承，子类（如果不是抽象类）必须重写抽象类中的所有抽象方法。

                     4 定义格式 ： 

                             abstract class className{

                                            属性        方法         抽象方法 }

                      5 抽象类不能直接实例化，要通过子类进行实例化。

 abstract class A{

    public abstract void say();
    
}

 class B extends  A{

     public void say(){
         System.out.println("B重写的抽象类方法");
     }
}


public class ChouXiang {

    public static void main(String[] args) {
        B b = new B();
        b.say();
    }

}

                     注意在class A中，say方法，不能有主体，只能是say();

                   6  对象的多态性

                         向上转型：程序会自动完成。        父类 父类对象 = 子类实例

                         向下转型：强制类型转换。            子类 子类对象 =（子类）父类实例

class AA{

    public void tell1(){
        System.out.println("A tell 1 ");
    }

    public void tell2(){
        System.out.println("A tell 2");
    }

}

class BB extends AA{

   public void tell1(){
        System.out.println("B tell 1");
    }

    public void tell3(){
        System.out.println("B tell 3");
    }
}

public class DuoTai {

    public static void main(String[] args) {

        //向上转型               父类 父类对象 = 子类实例
//        BB b = new BB();       //两部相当于  AA a = new BB()
//        AA a = b;
//        a.tell1();       // --> B tell 1   重写
//        a.tell2();       // --> A tell 2

        //向下转型           子类 子类对象 = （子类）父类实例
       AA a = new BB();
       BB b = (BB)a;
        b.tell1();         // -->B tell 1
        b.tell2();         // --> A tell 2
        b.tell3();         // --> B tell 3

    }

}

                         7  instanceof关键字

                         在java中可以使用instanceof关键字判断一个对象到底是不是一个类的实例。

                          配合上面代码使用。

//使用instanceof关键字判断一个对象是不是一个雷的实例

AA a = new AA();
System.out.println(a instanceof  AA);
System.out.println(a instanceof  BB);

AA a1 = new BB();
System.out.println(a1 instanceof  AA);
System.out.println(a1 instanceof  BB);

                          很明显a 是 AA对象的实例，而a1不是BB对象的实例。

               8 集合       list子接口    set子接口    collection总接口

public static void main(String[] args) {
    //可重复 按插入顺序排列
    List list = new ArrayList();
    list.add("a");
    list.add("a");
    list.add("d");
    list.add("e");
    list.add("b");
    list.add("c");
    list.add("a");
    System.out.println(list);

    //迭代器  将元素一个个判断，是否有内容，有则取出
    Iterator iterator = list.iterator();
    while (iterator.hasNext()){
           System.out.println(iterator.next());
    }

    //补课重复 按英文字母排序
    Set set = new HashSet();
    set.add("Z");
    set.add("A");
    set.add("B");
    set.add("G");
    set.add("Y");
    set.add("A");
    System.out.println(set);


    //补课重复 按英文字母排序
    Set set2 = new TreeSet();
    set2.add("A");
    set2.add("Z");
    set2.add("F");
    set2.add("V");
    set2.add("B");
    set2.add("A");
    System.out.println(set2);

}

                      Map接口：子类 HashMap ：无序存放，key不允许重复

                                       子类 Hashtable  : 无序存放，key不允许重复

                       map也可以使用迭代器。map是key-value的形式存储。

遇到的问题：

                   无

收获：

                 回顾基础知识。