学习日志day9（2021-07-15）（1、构造方法 2、方法重载 3、类的继承 4、抽象类 5、类的多态 6、接口 7、常量）

学习内容：学习JavaSE（Day9）

1、构造方法
2、方法重写与方法重载
3、类的继承
4、抽象类
5、类的多态
6、接口
7、常量

---

1、构造方法

（1）构造方法没有返回类型 包括void(void 也是一种放回类型)，构造方法没有返回值，并且构造方法的名称和类的名称一致。构造方法不需要我们手动生成，编译器会自动帮咱们生成。构造可以自己定义,但如果自己定义了构造方法，那编译器不会帮咱们自动生成无参的构造方法了。构造方法由new关键字调用，构造方法的作用是用来创建对象的。构造方法之间可以通过this() 来相互调用，类中的其它方法不能调用构造方法

public class Dog {

    public String name;
    private int age;
    
    //方法的重载：方法名称相同，参数列表不同
    public Dog(){
    /**
    *如果构造方法调用了另外一个构造方法，那该条调用语句必须写在该构造方法的第一行
    */
        this("Alex",12); 
        System.out.println("create a dog....");
    }

    public Dog(String name,int age){
        this.name = name;
        this.age = age;
    }

    public Dog(int age,String name){
        getName();
        this.name = name;
        this.age = age;
    }

public class DogTest {
    public static void main(String[] args) {
    Dog dog = new Dog("Rose",12);
    Dog dog1 = new Dog();
    }
}

2、方法重写与方法重载

（1）方法重写：

当子类中的方法和父类中的方法一致时，此时会形成方法的重写。在重写时子类中的访问修饰符可以大于或等于父类中的访问修饰符。当一个子类重写了父类中的方法时，那该子类调用时会执行子类中的方法。在子类中可以通过super关键字来调用父类中的方法。

//@Override 注解 ：防止在重写父类中的方法时出错
@Override
 public void eat() {
    System.out.println("我爱吃鱼。。。");
    super.say();
}

（2）方法重载：

在同一个类中多个方法之间方法名相同，参数列表不同，就会形成方法重载。与返回值和访问修饰符无关。

public Dog(){ 
	this("白色","boy"); 
}
public Dog(String color,String sex){ 
	this.color = color; 
	this.sex = sex; 
	System.out.println("wang wang..."); 
}

重写与重载之间的区别
方法重载：
1、同一个类中
2、方法名相同，参数列表不同（参数顺序、个数、类型）
3、方法返回值、访问修饰符任意
4、与方法的参数名无关
方法重写：
1、有继承关系的子类中
2、方法名相同，参数列表相同（参数顺序、个数、类型），方法返回值相同
3、访问修饰符，访问范围需要大于等于父类的访问范围
4、与方法的参数名无关

（3）访问修饰符的访问范围：

3、类的继承

（1）Java中通过extends关键字来实现继承，被继承的类称为父类（超类，基类），继承的这个类称为子类。
（2）在Java中的类只有单继承，一个类不能继承多个父类
（3）一个子类继承了一个父类之后，那该子类就拥有了父类的非私有方法或属性
（4）Object 是个类，并且是所有类的根类
（5）当父类中没有无参的构造方法时，子类中必须显示声明一个构造方法
（6）在子类的构造方法中使用super()调用父类的构造方法，只能在第一行调用，且只能调用一个父类的构造方法。
（7）如果不想调用父类中的构造方法，可以在父类中显示声明一个无参的构造方法。
（8）在同一个构造方法中不可以同时调用父类的构造方法和自己的构造方法。
（9）在创建一个对象时，所有继承下来的构造方法都会执行。

public class Animal {
	public Animal(){}
	public Animal(String color){
	    System.out.println("create a animal...");
	}
	void say(){}
}

public class Cat extends Animal{
	public Cat(){
	    super("yellow");
	    System.out.println("");
	}
	public Cat(String color){
	    this();
	    say();
	    super.say();
	}
	void say(){}
}

4、抽象类

（1）abstract 关键字修饰的方法都是抽象方法，抽象方法没有方法体。
（2）如果一个类中有抽象方法，那该类必须是抽象类，抽象类主要是为被继承。
（3）抽象类中可以有普通方法，可以没有抽象方法。
（4）抽象类有构造方法，但不能被实例化。
（5）抽象类中的构造方法在子类的构造方法被调用时，也会被调用。
（6）子类继承了一个抽象类之后，必须重写父类中所有的抽象方法。
（7）抽象方法不能被private、static、final修饰。

public abstract class Animal {  
    String name;
    public Animal(){}
    public Animal(int age){
        System.out.println("create a animal....");
    }
    public abstract void say();
    public  void run(){
        System.out.println("animal run....");
    }
}

5、类的多态

（1）父类指向子类：子类中定义的方法在父类中没有的话是不能被调用的，子类重写的方法是可以被调用的。这里调用的是Dog类中重写的run（）方法和say（）方法。

Animal animal = new Dog();//向上转型  父类指向子类 多态： 多种形态
animal.run();
animal.say();

（2）如果一个方法的参数是一个父类时，那可以传入该父类的所有子类。

public void feed(Animal animal){
    Cat cat = (Cat)animal; //强制类型转换
    System.out.println("我饲养了一个动物" + cat.name);
}

（3）如果一个方法的返回类型是一个父类，那该方法可以返回该父类的所有子类，调用时需要进行强制类型转换。

public Animal getAnimal(){
    return new Dog();
}

Dog dog = (Dog)p.getAnimal(); //向下转型

6、接口

（1）接口是高度抽象的抽象类，接口由interface 关键字来声明。
接口不做任何实现，接口中的方法都是抽象方法，不能有普通方法 ，接口中的方法默认由 public abstract 关键字来修饰。接口没有构造方法不能被实例化。
在java8环境下，可以定义具体的方法：
1.使用关键字static定义具体的静态方法，可以直接使用接口名称调用，不可以使用实现类调用。
2.使用关键字default定义具体的默认方法，实现这个接口的实现类定义的对象可以直接调用。当实现类同时实现的多个接口中都有相同的default方法时，需要重写default方法。

public interface Usb {
    void start();
    void exit();
}

（2）类使用implements 关键字来实现接口，一个类实现了一个接口，那该类必须重写接口中的所有抽象方法（该类是抽象类则不用实现），实现接口的类叫做实现类。

public class Mouse implements Usb{
    @Override
    public void start() {
        System.out.println("鼠标启动。。。");
    }
    @Override
    public void exit() {
        System.out.println("鼠标退出。。。");
    }
}

（3）类可以实现多个接口,接口之间使用逗号分隔。

public class KeyBoard implements Usb,C{
    @Override
    public void start() {
        System.out.println("键盘启动。。。");
    }
    @Override
    public void exit() {
        System.out.println("键盘退出。。。");
    }
}

（4）如果一个方法的参数是一个接口，那可以传入该接口的所有实现类。

public class Pc {
    public void run(Usb usb){
        usb.start();
    }
    public void exit(Usb usb){
        usb.exit();
    }
}

（5）如果一个方法的返回值是一个接口，那可以返回该接口的所有实现类。

public class Person {
    public Usb getMouse(){
        return new Mouse();
    }
}

（6）usb是一个Usb实例，只能调用接口中定义的方法，接口中没有定义的方法是不能被usb调用的。

public class PcTest {
    public static void main(String[] args) {
        Usb usb = new Mouse(); //向上转型 接口指向实现类
        usb.start();
        Person p = new Person();
        Mouse mouse = (Mouse) p.getMouse();
        p.show(mouse);
        Pc pc = new Pc();
        Mouse mouse1 = new Mouse();
        pc.run(mouse1);
        pc.exit(mouse1);
        KeyBoard kb = new KeyBoard();
        pc.run(kb);
        pc.exit(kb);
    }
}

（7）接口不能继承类，接口可以继承多个接口，接口之间使用逗号分隔。

public interface C extends D,E{
}

（8）函数式接口：就是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。可以使用注解@FunctionalInterface进行声明，以免团队的其他人员错误地往接口中添加新的方法。函数式接口可以被隐式转换为 lambda 表达式。
比如定义了一个函数式接口，使用Lambda表达式来表示该接口的一个实现如下：

@FunctionalInterface
interface GreetingService 
{
    void sayMessage(String message);
}

//传入一个参数message到GreetingService接口的saymessage方法
GreetingService greetService1 = message -> System.out.println("Hello " + message);

6、常量

（1）接口中没有实例变量，只能定义常量。使用final 关键字修饰的变量就是常量，常量必须有初始值。常量的命名规则：都是大写，如果包含多个单词，单词与单词之间使用下划线分隔。接口中的常量默认由static final 两个关键字来修饰，常量一但定义好不能被修改。

public interface C extends D,E{
   static final String NAME_CODE = "Rose";
}

（2）常量使用 “接口名.常量名” 调用。

public class CTest {
    public static void main(String[] args) {
        System.out.println(C.NAME_CODE);
    }
}

（3）final 修饰的类不能被继承，final 修饰的方法不能被重写。String就是final修饰的。