JavaSE进阶知识汇总(一)

idea使用

创建项目后，先创建模块  file->new->Module

idea快捷键

删除一行  ctrl+y

凡是新增或新建的快捷键都是 alt+insert

切换java程序  alt+左右箭头

运行  ctrl+shift+f10

提示方法的参数  ctrl+p

alt+数字可以打开对应数字的窗口

光标回到行头和行尾   home和end键

多行注释  ctrl+shift+/

纠正错误  alt+enter

代码全屏 ctrl+shift +F12

查看一个类的属性和方法  ctrl+F12

替换同一变量的所有变量名  shift+F6

final关键字

    1.1、final修饰的类无法继承。
    1.2、final修饰的方法无法覆盖。
    1.3、final修饰的变量只能赋一次值。
    1.4、final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用指向的对象内部的数据是可以修改的。
    1.5、final修饰的实例变量必须手动初始化，不能采用系统默认值。
    1.6、final修饰的实例变量一般和static联合使用，称为常量。
            public static final double PI = 3.1415926;

final static用来修饰常量 

抽象类

        第一：抽象类怎么定义？在class前添加abstract关键字就行了。
        第二：抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
        第三：final和abstract不能联合使用，这两个关键字是对立的。
        第四：抽象类的子类可以是抽象类。也可以是非抽象类。
        第五：抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的。
        第六：抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中。
        第七：抽象方法怎么定义？
            public abstract void doSome();
        第八（*****）：一个非抽象的类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现。

        面试题（判断题）：java语言中凡是没有方法体的方法都是抽象方法。
            不对，错误的。
            Object类中就有很多方法都没有方法体，都是以“;”结尾的，但他们
            都不是抽象方法，例如：
                public native int hashCode();
                这个方法底层调用了C++写的动态链接库程序。
                前面修饰符列表中没有：abstract。有一个native。表示调用JVM本地程序。

 

//抽象类无法实例化，无法创建对象，所以抽象类是用来被子类继承的

//final修饰的类无法被继承，所以final和abstract不能一起使用
//报错：非法的修饰符组合: abstract和final
/*final abstract class Account {

}*/

//抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的
abstract class Account {
    public Account(String s) {

    }
}

//抽象类的子类可以是抽象类
abstract class CreditAccount extends Account {
    public CreditAccount() {
        super("111");
    }

}

抽象方法

一个非抽象类继承了一个抽象类，必须将抽象类中的抽象方法给实现（覆盖）了才不会报错

abstract class Account {
    public Account(String s) {

    }

    // 抽象方法表示没有实现的方法
    // 抽象类中可以没有抽象方法，但抽象方法必须出现在抽象类中
    // 抽象方法特点：没有方法体，前面的修饰符有abstract
    abstract public void doSome();

    public void doElse() {

    }
}

抽象类和抽象方法总结 

接口

接口的基础语法

interface A {
    public static final double PI = 3.14;

    // public static final可以直接省略，但这个变量还是常量
    double PI1 = 3.14;

    public abstract void move();

    // public abstract可以直接省略，但这个方法还是抽象方法
    void move1();

}

interface B {

}

interface C extends A, B {

}

 

public class Test04 {
    public static void main(String[] args) {
        Math m1 = new MyMath2();
        System.out.println(m1.sum(10, 20));

    }
}

interface Math {
    double PI = 3.14;

    int sum(int a, int b);
}

//implements为实现，相当于extends
abstract class MyMath1 implements Math {

}

class MyMath2 implements Math {
    @Override
    public int sum(int a, int b) {
        return a + b;
    }
}

一个类可以同时实现多个接口 

public class Test05 {
    public static void main(String[] args) {
        A a = new C();
        a.sum1();

        B b = new C();
        b.sum2();
    }
}

interface A {
    void sum1();
}

interface B {
    void sum2();
}

class C implements A, B {
    @Override
    public void sum1() {
        System.out.println(1);
    }

    @Override
    public void sum2() {
        System.out.println(2);
    }
}

继承和实现同时存在时，extends关键字在前，implements关键字在后

public class Test06 {
    public static void main(String[] args) {
        FlyAble f = new Cat();
        f.fly();
    }
}

class Animal {

}

interface FlyAble {
    void fly();
}

class Cat extends Animal implements FlyAble {
    @Override
    public void fly() {
        System.out.println("飞猫来也");
    }
}

 接口在开发中的作用

面向接口编程，可以降低程序的耦合度，提高程序的扩展力，接口的使用离不开多态机制

接口可以解耦合，下面代码解的是顾客和厨师的耦合，接口都有调用者和实现者，调用者面向接口调用，实现者面向接口编写实现，顾客是调用者，厨师是实现者

顾客有菜单，凡是可以has a 表示的都可以当做这个类的属性

将菜单提取出来，降低了厨师和顾客之间的耦合度，顾客只要点菜单就行，不需要经过厨师，而且如果我们要吃其他国家的菜，只要增加该国家的厨师类，顾客类、菜单类、中国厨师类、美国厨师类都不需要改动，符合对修改关闭，对扩展开放的OCP原则

public class Test07 {
    public static void main(String[] args) {
        FoodMenu cook1 = new ChineseCook();
        Customer c1 = new Customer(cook1);
        c1.order();

        FoodMenu cook2 = new AmericCook();
        Customer c2 = new Customer(cook2);
        c2.order();
    }
}

class Customer {
    private FoodMenu foodMenu;

    public Customer(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }

    public FoodMenu getFoodMenu() {
        return foodMenu;
    }

    public void setFoodMenu(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }

    public void order() {
        foodMenu.chaojidan();
        foodMenu.chaoniurou();
    }
}

interface FoodMenu {
    void chaojidan();

    void chaoniurou();
}

// 中国厨师
class ChineseCook implements FoodMenu {
    @Override
    public void chaojidan() {
        System.out.println("中国厨师的炒鸡蛋做好了");
    }

    @Override
    public void chaoniurou() {
        System.out.println("中国厨师的炒牛肉做好了");
    }
}

// 美国厨师
class AmericCook implements FoodMenu {
    @Override
    public void chaojidan() {
        System.out.println("美国厨师的炒鸡蛋做好了");
    }

    @Override
    public void chaoniurou() {
        System.out.println("美国厨师的炒鸡蛋做好了");
    }
}

类型和类型之间的关系：is a，have a，like a

is a（继承）、has a（关联）、like a（实现）

            is a：
                Cat is a Animal（猫是一个动物）
                凡是能够满足is a的表示“继承关系”
           &nb