java初学者日志_03

继承：
1.父类也称超类，基类，派生类
2.java中只有单继承
3，java中类没有多继承，接口有多继承
4.子类继承父分类，可以得到父类的全部属性和方法（除了父类的构造方法），但不见得可以直接访问（父类私有的属性和方法）
定义一个类型，没有调用extends，则默认父类为 java.lang.Object
继承的作用：代码复用，建模

final
1.修饰变量，被修饰的变量不可改变（常量）
2.该方法不可被子类重写
3.修饰的类不能被继承

想要使用别的类的代码有两种办法：
1继承（认爸爸）
2组合（吸收它）

组合：将父类对象作为子类的属性
当需要两个父类的对象时，可以使用组合

is-a用继承（Student is a person）
has-a用组合（Student has a person）

```java
package com.jc;

public class Person {
    String name;
    int height;

    public void rest(){
        System.out.println("休息");
    }
    public  Person getfriend(){
        return new Person();
    }
    public static void main(String[] args) {
        Student s=new Student("法外狂徒",180,90);
        System.out.println(s instanceof Person);
        System.out.println(s.height);
        Person p=new Person();
        p.rest();
        s.study();
        s.rest();//在没有重写之前，调用的是Person里边的rest
    }
}
//组合
class teacher{
    int tracherid;
    Person p=new Person();
    teacher(int tracherid,String name,int height){
        this.tracherid=tracherid;
        this.p.name=name;
        this.p.height=height;
    }
}
//继承
class Student extends Person{
    int score;
    public void study(){
        System.out.println("休息"+this.name);
    }
    //将rest重写
    public void rest(){
        System.out.println("好好休息"+this.name);
    }
    Student(String name,int height,int score){
        this.name=name;
        this.score=score;
        this.height=height;
    }
}

return的作用：返回值，结束方法运行
```java
package com.text.text2;

import java.util.Objects;

public class User {
    int id;
    String name;
    int pwd;
    User(int id,String name,int pwd){
        this.id=id;
        this.name=name;
        this.pwd=pwd;
       // System.out.println("id:"+this.id +"name"+this.name+"pwd:"+pwd);
    }

    public static void main(String[] args) {
        User u1=new User(1001,"张三",123456);
        User u2=new User(1001,"张四",123456789);

        /*String x="asdzxc123";
        String y="qazwsx321";
        System.out.println(x+y);*/
        System.out.println(u1);

        System.out.println(u2.toString());
        System.out.println(u1==u2);//==就是判断是不是同一个对象
        System.out.println(u1.equals(u2));//equals判断两个对象逻辑上的值是不是一样
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id;
    }

    @Override
    public int hashCode() {
        return Objects.hash(id);
    }
}

equals代码块

public boolean equals(Object obj){
    if(obj==null){
        return false;
    }
    else{
        if(obj instanceof Person){
            Person c=(Person)obj;
            if(c.id==this.id){
                return true;
            }
        }
    }
    return false;
}

super可以看做“直接父类对象的引用”，通过super访问父类中被子类覆盖的方法或属性
只能用于子类中

public class superceshi {
    public static void main(String[] args) {
        new ChildClass().f();
    }
}
class FatherClass{
    public int value;
    public void f(){
        value=100;
        System.out.println("FatherClass.value="+value);
    }
}
class ChildClass extends FatherClass{
    public int value;
    public void f(){
        super.f();//调用父类的普通方法
        value=200;
        System.out.println("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value);//调用父类的成员变量
    }
}

public class superceshi {
    public static void main(String[] args) {
        System.out.println("开始创建Child");
        new ChildClass();
    }
}
class FatherClass {
    public FatherClass() {
        System.out.println("创建FatherClass");
    }
}
class ChildClass extends FatherClass{
public ChildClass() {
    //编译器会自动在这里创建 super();
    System.out.println("创建ChildClass");
}
}

1一个类定义时，没有使用extends，则它的父类是：Object
2Object中toString()方法默认返回的字符串的含义是
3.==用于比较两个对象是否相同，equals在Object中的默认实现就是如此
4.equals方法一般用于比较两个对象“逻辑上的值是否相等”