javaday3

javaday3

this关键字

在构造函数中可以用this关键字带对应的参数调用对应的构造函数

public class Hero {
    String name; //姓名
    float hp; //血量
    //带一个参数的构造方法
    public Hero(String name){
        System.out.println("一个参数的构造方法");
        this.name = name; //this.name指的是这个对象的属性name，而name时这个函数的输入
    }
    //带两个参数的构造方法
    public Hero(String name,float hp)
    {
        this(name);                  //这里的this带有一个参数，就调用了第一个构造函数
        System.out.println("两个参数的构造方法");
        this.hp = hp;
    }
    public static void main(String[] args) 
    {
        Hero teemo =  new Hero("提莫",383);
        System.out.println(teemo.name);
        System.out.println(teemo.hp);
        
    }
}

集合容器

public class jiherongqi {
    public static void main(String[] args)
    {
        ArrayList<String> ar =new ArrayList<>();
        HashSet<String> jh =new HashSet<>();
        ar.add("one");
        ar.add("two");
        ar.add("one");
        jh.add("one");
        jh.add("two");
        jh.add("one");
        System.out.println(ar);
        System.out.println(jh);
    }
}

从中可以看出集合容器于普通的顺序容器的不同，集合容器中不允许出现同一个元素两次，可以直接用println加容器名打出容器内的元素，不用再写一个循环打出来。

哈希表

public class haxibiao {
    private HashMap<Integer,String> num=new HashMap<>();//构造哈希表
    public haxibiao()                   //没有参数输入的构造函数
    {                                    
        num.put(1,"one");
        num.put(2,"two");
        num.put(3,"three");
        num.put(4,"four");
    }
    public void get(int i)
    {
        System.out.println(num.get(i));
    }
    public static void main(String[] args)
    {
        haxibiao number=new haxibiao();    //建立新对象时同时也调用了构造函数
        Scanner in =new Scanner(System.in);
        int i =in.nextInt();
        number.get(i);
    }
}

HashMap< ，>后面的两个空必须填的时包裹类型，若填int这种将会报错

可以用 num.containsKey(int i)来验证哈希表中是否存在关键字为i的某个元素

哈希表中同一个关键词对应的元素一定唯一，并且是最新录入的那个元素，比如这个表中再录入一个num.put(4,“四”);那么4这个关键字对应的就是四不是four了

哈希表也可以直接用System.out.println（num）输出，与容器一样。

继承

public class jicheng {
    int a;
    char b;
    String s;
    public void prin1()
    {
        System.out.println("hi");
    }
     static class zilei extends jicheng {
        int abc;
        public void prin2()
        {
            System.out.println("hello");
        }
    }
    public static void main(String[] args)
    {
        zilei i=new zilei();
        i.prin1();
    }
}

这段代码里zilei就是jicheng的子类，所谓继承就是子类继承了父类的全部东西，并且自己还可以多加东西，子类和父类可以写在同一个源代码里也可以写在不同的源代码里，与权限有关，当子类和父类都有同一个函数但功能不同时（比如这里的prin2改成prin1)，那么会优先执行子类里的函数，就是打出hello。

如果一个函数需要的是父类的参数，那么这个时候用子类作为参数也可以

子类的对象可以当作父类的对象来使用（子类的对象可以传给父类：fulei i =new zilei()）

容器放父类时也一定可以放子类

因为Java中保存对象类型的变量是多态变量，可以保存其声明的类型的对象,或该类型的任何子类型的对象。

父类中private的东西只有父类自己可以访问，改成protected则子类以及同包中的都可以访问，public则都可以访问

super的用法

class fulei
{
    int a;
    char b;
    String s;
    fulei()
    {
    }
    fulei(int i,char j)
    {
        a=i;
    }
    public void prin1()
    {
        System.out.println("hi");
    }
}
class zilei extends fulei
{
    int abc;
    zilei()
    {
        super();
    }
    zilei(int i,char j) {
        super(i,j);
    }
    public void prin2()
    {
        System.out.println("hello");
    }
}

如果需要使用构造函数zilei()new一个新的对象并且父类中有定义构造或者构造函数构造的对象 那么zilei中必须写zilei这个构造函数，并且根据zilei()中参数的个数写一个super()（如果说父类中有一个没有参数的构造函数，那么子类中对应的构造函数可以不写super()因为super就是用来传参参数的，不用传参数的时候也就不用用到super），super()函数的目的是将用构造函数zilei()传入的参数传到父类的构造函数之中自动调用父类的构造函数构造一个子类的对象时的顺序为：父类的定义构造—>父类的构造函数构造—>子类的定义构造—>子类的构造函数构造。

如果需要用到super的时候，super都必须写在构造方法的第一行

如果子类和父类中有同名变量，那么这个变量在子类中是指子类的东西，在父类中是指的父类的东西，互不相干

如果须在子类中调用父类的东西，可以使用super.(父类的东西)

造型

子类的对象可以传给父类，但反过来父类的对象不能传给子类，如果需要强制传输，就必须要造型

zilei i =new zilei();
fulei j=i;                    //这部叫做向上造型，父类j实际上是子类的类型
zilei k=j;                   //不可以，这样是错的需要造型：zilei k=(zilei)j;

如果需要使用造型时，则父类的对象必须实际上管理的是子类，就比如上述例子中j=i，父类j实际上管理的是子类i，所以才能够造型成功.

造型和类型转换不一样，造型只是把它另一个类型来使用，实质上是没有变，而类型转换是改变它的实质，使它真正成为另一个类型。

object类

object类中有很多函数，比如就是toString()和equals()这两个函数都可以根据自己的需求进行更改

右键Generate里面有toString和equals可根据详细的需求进行更改。toString就是把一个变量自动转化为字符串，equals就是判断两个字符串是否相等（不是管理的对象相等，而是真正意义上的相等）

设计原则

1.消除代码复制

2.封装降低耦合，每一个类中做好自己的类应该做好的，使得public的成员变量尽量少，外部需要时用相关的函数传出去（耦合是指类与类之间的关系）

3.可扩展性 用容器来实现灵活性，可以用哈希表，前面是对应的关键字，后面是相对的变量，比如说前面是north后面是kitchen那么就可以得知这个房间的北部是厨房 框架+数据提高可扩展性