Java学习【Day 5】

要突击两场考试了，暂且抽时间学一下Java吧

Super关键字

“代表当前对象的父类特征”。表示通过子类的构造方法调用父类的构造方法 。模拟现实世界的：要想有儿子，需要先有父亲
语法：

1. super.
2. super()

当一个构造方法中的第一行：
既没有this()又没有super()，默认会有一个super()来调用父类的无参构造方法

this()和super()是不能并存的，两者都只能出现在 构造方法的第一行。

无论如何，父类的构造方法是一定会执行的

该方法和this()对比着看，this()是调用本类中另一个构造方法，而super是调用父类中的构造方法

在Java中，无特殊说明继承关系的话，默认是继承自Object类，它是“老祖宗”
因此在执行时Object类的无参数构造方法一定会被执行，它处于“栈顶”

package Demo;

public class Test_super {
    public static void main(String[] args){
        new B(66);
    }
}

class A{
    public A(){
        System.out.println("A类的无参数构造方法");

    }
    public A(int i ){
        System.out.println("A类的有参数构造方法");
    }
}

class B extends A{
    public B(){
        super(6);    //没写的话默认有一个super()，表示调用父类的无参数构造方法
        System.out.println("B类的无参数构造方法");
    }
    public B(int i ){
        this(); //调用本类的无参数构造方法
        System.out.println("B类的有参数构造方法");
    }
}
/*
A类的有参数构造方法
B类的无参数构造方法
B类的有参数构造方法
*/

IDEA 快捷键

快速生成main方法								psvm 或者 main

快速生成System.out.println();				sout

删除行										Ctrl+Y

新增、新建、添加								Alt + insert

切换窗口										Ctrl + TAB  或者 Alt + 左右箭头
	
移动代码块									Ctrl + ALT + 方向键

右侧Project栏列表的展开关闭					左箭头关闭		右箭头展开

提示参数										Ctrl + P

单行注释										Ctrl + /
多行注释										Ctrl + shift + /

打开设置面板									Ctrl + Alt + s

查看当前类的层次结构							Ctrl + H

快速检索类									Ctrl + N

final关键字

final 表示最终的、不可改变的
final 可以修饰变量以及方法，还有类等

• final 修饰的类无法被继承
• final 修饰的方法无法被重写
• final 修饰的变量只能赋一次值

final class String{}
public final void A(){}
final int dmind = 666;

final修饰的实例变量：

如果没有给实例变量赋值的操作，则会报错： 可能尚未初始化变量i

• 实例变量在什么时候赋值？
  在构造方法执行的时候赋值（new的时候赋值）

两种赋值方法：

1. 可以在直接赋值：final int i =666;
2. 可以在构造方法中赋值，如下

package Demo;

public class Test_final {
    public static void main(String[] args) {
        C dmind = new C(5);
        System.out.println(dmind.i);
        }
}

class C {
     final int i ;		//也可以这样赋值：final int i = 666 ;
     public C(int i){   //实例变量在构造方法中赋值，不会报错。
        this.i = i;
    }

}

总之，一定要记得给final修饰的变量赋值，系统不参与赋值！！

常量

常量的值不可改变。常量和静态变量都是存储在方法区，并且都是在类加载时初始化。
常量建议全部大写，各个单词之间才有下划线衔接

public static final int MAX_NUMBERS = 100;

1. 只用final修饰，值一定不变，但该变量可能有多份（内存空间中有多份）
2. 只用static修饰，可以保证唯一，但不能保证变量不被修改
3. final与static一起修饰，既保证不被修改，也保证唯一。

抽象类（abstract）

类与类之间具有共同的特征，将这些共同特征提取出来形成的就是抽象类。

语法：

[修饰符列表] abstract class 类名{
	类体;
} 

抽象类是用来被子类继承的。

抽象方法：没有实现的方法，没有方法体的方法。

public abstract void something();

特点：

1. 没有方法体，即没有大括号。以分号结尾
2. 修饰符列表中要有 abstract 关键字

抽象类中可以没有抽象方法，有非抽象的方法。但抽象方法一定出现在抽象类中

子类是abstract类，允许子类将父类的非abstract方法重写为sbstract方法

重点：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现

final和abstract不能联合使用、不允许使用static修饰abstract方法，否则如何覆盖/重写/实现？

package Demo;

public class Test_abstract {
    public static void main(String[] args){
    }
}

//定义一个抽象类
abstract class Accounts{
   public void dosomething(){}      //抽象类中可以有非抽象方法

    public abstract void doOther(); //抽象方法，没有方法体，不能加括号
}

//定义一个非抽象类
class CreditAccounts extends Accounts{
    public CreditAccounts(){		//构造方法，默认调用super()
        super();
    }
    public void doOther(){}     //因为本类不是abstract，要重写父类中的抽象方法，把abstract去掉
}

接口（interface）

1. 接口是完全抽象的，抽象类是半抽象的，接口是一种特殊的抽象类
2. 接口支持多继承，一个接口继承多个接口
3. 定义

[修饰符列表] interface 接口名{} 

interface A{}
interface B extends A{}

4. 接口中只包含两部分内容：常量、抽象方法
5. 接口中所有元素都是public 修饰的，都是公开的
6. 接口中定义常量，可以省略public static final修饰符。
7. 接口中所有方法都是抽象方法，因此都没有方法体；定义抽象方法时，可以省略public abstract修饰符。
8. 定义接口时，在interface前加上public关键字，这样的接口是一个public接口，可以在任何一个类实现。如果不加上public修饰，就称为友好接口，可以被与该接口在同一包中的类实现。

例子：

package Demo;

public class Test_interface {
    public static void main(String[] args) {
        System.out.println(Mymath.PI);
    }
}

interface Mymath{
    //接口中定义常量，可以省略public static final。下面两个等效
    double PI1 = 3.1415926;
    public static final double PI = 3.1415926;


    //接口中定义抽象方法，可以省略public abstract。下面两个等效
    int add1(int a,int b);
    public abstract int add(int a,int b);
}

类实现接口

1. 类和类之间叫做继承、类和接口之间叫做实现。
2. 当一个非抽象的类实现接口，必须将接口中所有的抽象方法全部实现

package Demo;

public class Test_interface1 {
    public static void main(String[] args) {
        MyMathImp a = new MyMathImp();
        System.out.println(a.sum(4,21));    //25
    }

}

//定义MyMath接口
interface MyMath{
    double PI = 3.14;
    int sum(int a, int b);
    int sub(int a, int b);
}

//定义一个非抽象类MyMathImp，继承MyMath接口
class MyMathImp implements MyMath{
    public int sum(int a, int b){
        return a+b;
    }
    public int sub(int a, int b){
        return a-b;
    }

}

接口与多态的联合

package Demo;

public class Test_interface1 {
    public static void main(String[] args) {
        //父类型的引用指向子类型的对象
        MyMath dd = new MyMathImp();
        //调用接口中的方法
        dd.sub(4,5);
        //dd.kk(4);     此行是错误的，父类型(即接口)中不存在此方法
    }

}

//定义MyMath接口
interface MyMath{
    double PI = 3.14;
    int sum(int a, int b);
    int sub(int a, int b);
    //int kk (int a);
}

//定义一个非抽象类MyMathImp，继承MyMath接口
class MyMathImp implements MyMath{
    public int sum(int a, int b){
        return a+b;
    }
    public int sub(int a, int b){
        return a-b;
    }
    public int  kk (int a){
        return a;
    }

}

一个类可以实现多个接口

一个类可以同时实现多个接口。这种机制弥补类java中：类和类只支持单继承的缺陷。

public class Test_interface2 {
    public static void main(String[] args) {
        D foo = new D();
        foo.B();
        //向上转型
        A bar = new D();
        bar.A();
        //接口转型，从A接口转为B接口，调用其独有的方法
        B dd = (B) bar;
        dd.B();

        //下面两行运行会报错，但编译不会：ClassCastException: D cannot be cast to C
        //接口和接口之间在强制类型转换时，即使没有继承关系也能强转，编译没问题，但运行报错
        D kk = new D();
        C tt = (C) kk;
    }
}

interface X{
}
interface Y{
}
//接口与接口之间可以多继承，extendes
interface Z extends X,Y{
}


interface A{
    void A();
}
interface B{
    void B();
}
interface C{
    void C();
}

//一个类实现多个接口，类似于多继承
class D implements A,B{
    public void A(){
        System.out.print("A方法");
    }
    public void B(){
        System.out.print("B方法");
    }
}

一个类同时继承父类、实现接口

继承与实现都存在，则 extends 关键字在前， implements关键字在后

public class Test_interface3 {
    public static void main(String[] args){
        Flyable cat = new Cat();    //多态
        cat.fly();
        Flyable pig = new Pig();    //多态
        pig.fly();
    }
}

interface Flyable{	//具有飞功能
    void fly();
}
//父类
class Animal {
}

//extends 关键字在前， implements关键字在后
class Cat extends Animal implements Flyable{
    //必须实现接口的方法
    public void fly(){
        System.out.println("能飞的猫");
    }
}

class Pig extends Animal implements Flyable{
    public void fly(){
        System.out.println("能飞的猪");
    }
}

类和类之间的关系

is a	继承关系
	Cat is a Animal
	例如：Cat extends Animal 	//Cat继承Animal


has a 	关联关系，以属性方式存在
	A has a B
	例如：class A{
					B b;	//B以成员变量的形式存在于A中
				}


like a	实现关系
	Cook like a Foodmenu
	例如： class Cook implements Foodmenu{}		//类实现接口

抽象类与接口区别

抽象类是半抽象的
接口时完全抽象的

抽象类中没有构造方法
接口中没有构造方法

接口和接口之间支持多继承
类和类之间只能单继承

一个类可以同时实现多个接口
一个抽象类只能继承一个类（单继承）

接口中只允许出现常量和抽象方法

一般接口使用的比较多，一般抽象类使用比较少
接口一般都是对“行为”的抽象