一、抽象概述

• 不具体的，似是而非的

• 没有具体实现的

• 比如Animal，只是对动物的大概描述

  • 能吃

  • 能睡

• 具体吃啥，怎么睡我们无从得知，创建出来的对象意义不大

• 我们认为这种类不应该直接创建对象，应该让其子类创建具体的对象

• 怎么限制？做成抽象类

  • abstract修饰的类可以变成抽象类

   

二、抽象类（重点）

2.1 定义

• 被abstract修饰的类成为抽象类

• 无法直接创建对象

• 抽象类中可以存在抽象方法

package com.qf.abs;
?
public class Demo01 {
    public static void main(String[] args) {
        // 抽象类无法直接创建对象
        // Animal animal = new Animal();
    }
}
?
abstract class Animal{
    
    public abstract void eat();
    
}
?

2.2 抽象类的子类和对象

• 抽象类无法直接创建对象，但是可以有子类

• 抽象类的子类继承抽象类之后可以获取到抽象类中的非私有普通属性和方法

• 抽象类的子类如果想使用抽象类中的抽象方法，必须重写这些方法之后才能使用

• 如果不使用抽象方法，做成抽象类也是可以的

package com.qf.abs;
?
public class Demo01 {
    public static void main(String[] args) {
        // 抽象类无法直接创建对象
        // Animal animal = new Animal();
        Husky husky = new Husky();
        System.out.println(husky.type);
        husky.breath();
        husky.eat();
    
    }
}
?
/**
 * 抽象类Animal
 *  描述动物的一个类
 *  只做了大概的描述，没有具体的实现
 *  需要子类继承此类后做具体的描述
 * @author Dushine2008
 *
 */
abstract class Animal{
    
    // 属性
    String type = "动物";
    String section;
    
    public abstract void eat();
    
    public abstract void sleep();
    
    public void breath() {
        System.out.println("所有的动物都依赖氧气存活...");
    }
    
}
?
?
abstract class Dog extends Animal{
    
}
?
class Husky extends Dog{
?
    @Override
    public void eat() {
        System.out.println("二哈喜欢和主人同吃同住...");
    }
?
    @Override
    public void sleep() {
        System.out.println("二哈和主人同住同吃.................");
    }
    
}

三、抽象类和多态案例（掌握）

• 创建抽象类Car

• 创建Car的子类

  • Auto

  • Bus

  • Tractor

• 在子类重写继承的抽象方法和自己独有的方法

• 使用多态的思想创建对象并调用这些方法

package com.qf.abs;
?
public class Demo02 {
    public static void main(String[] args) {
        Car car01 = new Auto();
        car01.start();
        car01.stop();
        
        // 向下转型
        Auto auto = (Auto) car01;
        auto.manned();
        
        System.out.println("========================");
        
        Car car02 = new Bus();
        car02.start();
        car02.stop();
        
        // 拆箱
        Bus bus = (Bus) car02;
        bus.manned();
    
        System.out.println("========================");
        
        Car car03 = new Tractor();
        car03.start();
        car03.stop();
        
        Tractor tractor = (Tractor) car03;
        tractor.doFarmWork();
        
    }
}
?
/**
 * 车的顶层类
 *  抽象类
 *  方法没有具体的实现
 * @author Dushine2008
 *
 */
abstract class Car{
    // 属性
    int weight;
    int height;
    String brand;
    int price;
    
    // 方法
    public abstract void start();
    
    public abstract void stop();
}
?
/**
 * 奥拓车
 *  继承Car
 *  重写启动和停止的方法
 * @author Dushine2008
 *
 */
class Auto extends Car{
?
    @Override
    public void start() {
        System.out.println("Auto拧钥匙启动...");
    }
?
    @Override
    public void stop() {
        System.out.println("Auto这个车子刹车系统是鼓刹...");
    }
    
    public void manned() {
        System.out.println("Auto这辆小车能载人5个...");
    }
    
}
?
/**
 * Bus类
 *  继承了Car类
 *  重写抽象方法
 * @author Dushine2008
 *
 */
class Bus extends Car{
?
    @Override
    public void start() {
        System.out.println("Bus启动方式很多，可以拧钥匙，可以人力推，还可使用摇把启动...");
    }
?
    @Override
    public void stop() {
        System.out.println("Bus刹车使用脚刹...");
    }
    
    public void manned() {
        System.out.println("Bus载人数量能达到百人");
    }
    
}
/**
 * Tractor类
 *  继承了Car类
 *  重写抽象方法
 * @author Dushine2008
 *
 */
class Tractor extends Car{
?
    @Override
    public void start() {
        System.out.println("Tractor早期使用摇把，后来升级了电启动...");
    }
?
    @Override
    public void stop() {
        System.out.println("Tractor手扶拖拉机使用手刹,很拉风...");
    }
    
    public void doFarmWork() {
        System.out.println("Tractor可以在农场里干活...");
    }
    
}

四、static（重点）

4.1 定义

• static是java中的关键字

• 能修饰变量、方法、内部类

五、 静态变量（掌握）

• 被static修饰的变量成为静态变量--类变量--整个类中只存在一份

• 静态变量被所有此类创建的对象共享，在内存中只存在一份

• 在任意位置修改了这个变量，后面的对象获取到的就是修改之后的结果

• 推荐使用类名.属性名调用

4.2.1 非静态变量的创建和使用

package com.qf.static0;
?
public class Demo01 {
    public static void main(String[] args) {
        MyClass c01 = new MyClass();
        c01.str = "我是c01中的变量str";
        System.out.println(c01.str);
        System.out.println(c01);
        
        MyClass c02 = new MyClass();
        c02.str = "我是c02中的变量str";
        System.out.println(c02.str);
        System.out.println(c02);
        
    }
}
?
?
class MyClass{
    // 属性--实例变量--成员变量
    String str;
}
?

4.2.2 静态变量的创建和使用

package com.qf.static0;
?
public class Demo02 {
    public static void main(String[] args) {
        MyClass c01 = new MyClass();
        c01.str = "我是c01中的变量str";
        System.out.println(c01.str);
        System.out.println(c01);
        
        MyClass c02 = new MyClass();
        c02.str = "我是c02中的变量str";
        System.out.println(c02.str);
        System.out.println(c02);
        
        YourClass y01 = new YourClass();
        YourClass.capital = "我是韩国的国都汉城";
        System.out.println(YourClass.capital);
        System.out.println(y01);
        
        YourClass y02 = new YourClass();
        YourClass.capital = "我是韩国的国都首尔";
        System.out.println(y01.capital);
        System.out.println(y02);
        
    }
}
?
class YourClass{
    // 被static修饰的变量成为静态变量--类变量--整个类中只存在一份，被所有此类创建的对象共享，在内存中只存在一份
    static String capital;
}

4.2.3 内存图

4.2.4 记录对象创建次数

package com.qf.static0;
?
public class Demo03 {
    public static void main(String[] args) {
        System.out.println(OurClass.count);
        
        OurClass oc1 = new OurClass();
        System.out.println(OurClass.count);
        
        OurClass oc2 = new OurClass();
        System.out.println(OurClass.count);
        
        OurClass oc3 = new OurClass();
        System.out.println(OurClass.count);
        
        OurClass oc4 = new OurClass();
        System.out.println(OurClass.count);
    }
}
?
class OurClass{
    // 定义静态的变量count，记录被执行次数
    static int count = 0;
    
    public OurClass(){
        // 构造方法每一次调用都自增一下
        count++;
    }
}
?
class User{
    
}

六、静态方法（掌握）

6.1 定义

• static修饰的方法成为静态方法

• 不用创建对象就能直接调用

package com.qf.static0;
?
public class Demo04 {
    public static void main(String[] args) {
        // System.out.println(Integer.MIN_VALUE);
        // 调用静态属性
        System.out.println(MathUtil.PI);
        System.out.println(MathUtil.maxInteger);
        System.out.println(MathUtil.minInteger);
        
        // 调用静态方法
        double abs = MathUtil.getAbs(-23.45);
        System.out.println(abs);
        
        double pow = MathUtil.getPow(3, 0);
        System.out.println(pow);
        
    }
}
?
class MathUtil{
    
    // 属性
    static double PI = 3.141592653589793;
    static int maxInteger = 2147483647;
    static int minInteger = -2147483648;
    
    // 方法
    /**
     * 获取绝对值
     * @param d
     * @return
     */
    public static double getAbs(double d) {
        return d >= 0 ? d : -d; 
    }
    
    /**
     * 计算a的b次方的结果
     * @param a
     * @param b
     * @return
     */
    public static double getPow(double a,int b) {
        int result = 1;
        for (int i = 0; i < b; i++) {
            result *= a;
        }
        return result;
    }
    
}
?

6.2 静态方法调用其他属性和方法

• 静态方法调用静态属性

  • 可以

• 静态方法调用静态方法

  • 可以

• 静态方法调用非静态属性

  • 不可以

• 静态方法调用非静态方法

  • 不可以

package com.qf.static0;
?
public class Demo05 {
    public static void main(String[] args) {
        
    }
}
?
?
class Stu{
    // 实例属性,对象创建的时候加载到堆内存
    String name = "张三";
    // 静态属性,类属性,随着类的加载,加载的时间早于实例属性
    static int age = 23;
    
    // 实例方法,创建对象的时候加载进内存,加载的时间比静态的晚
    public String getInfo() {
        // 可以在非静态方法中调用静态方法和静态变量
        show();
        return name + "===" + age;
    }
    
    // 静态方法,随着类的加载而加载,加载时间早于实例属性,无法在此调用实例属性
    public static void show() {
        System.out.println(age);
        // 在静态方法中只能调用静态变量和静态方法
        // getInfo();
        // System.out.println(name);
    }   
}

6.3 静态方法、属性的继承

• 子类可以获取到父类中的实例属性、方法

• 子类可以获取到父类中的静态属性、方法

• 子类可以重写父类中的实例方法

• 子类不能重写父类的静态方法

package com.qf.static0;
?
public class Demo06 {
    public static void main(String[] args) {
        Man man = new Man();
        man.show();
        String info = man.getInfo();
        System.out.println(info);
        
        Human.type = "壮实的";
        man.show();
        
        man.type = "力气大的";
        System.out.println(Human.type);
        
    }
}
?
/**
 * 类Human
 *  人类
 *  有各种各样的属性和方法
 * @author Dushine2008
 *
 */
class Human{
    // 实例属性
    String name = "李四";
    
    // 静态属性,可以被继承
    static String type = "好看的";
    
    // 实例方法
    public void show() {
        System.out.println("我是" + name + ",我喜欢的类型是:" + type);
    }
    
    // 静态方法,子类可以调用,但是不能重写/覆盖
    public static String getInfo() {
        return "张三喜欢的类型:===" + type;
    }
}
?
class Man extends Human{
    @Override
    public void show() {
        System.out.println(name + ",我不仅仅喜欢===" + type);
    }
    
    /*@Override
    public static String getInfo() {
        return "张三喜欢的类型不仅仅是:===" + type;
    }*/
}
?

七、代码块

7.1 局部代码块（熟练）

7.1.1 定义

• 定义在方法中的代码块成为局部代码块

• 随着所在方法的调用而执行

• 可以调用所在方法和类中的变量

• 代码块内部也可以定义变量，外部访问不到

• 适合临时用一下的一些数据的处理

7.1.2 案例

package com.qf.block;
?
public class Demo01 {
    static  int  num = 33;
    public static void main(String[] args) {
        int a = 110;
        
        System.out.println("HelloWorld01");
        System.out.println("HelloWorld02");
        
        {
            // 局部代码块
            // 无痕浏览
            int b = 220;
            System.out.println("我是main方法中的局部代码块" + num);
        }
        
        System.out.println("HelloWorld03");
        System.out.println("HelloWorld04");
        System.out.println("HelloWorld05");
        
    }
}

7.2 动态代码块(构造代码块)（掌握）

7.2.1 定义

• 定义在类中的代码块，位置和构造方法、实例变量同一级

• 每一次创建对象的时候被调用

• 可以完成构造方法中相同或者相似的代码,对构造方法进行初始化

7.2.2 案例

package com.qf.block;
?
public class Demo02 {
    public static void main(String[] args) {
        
        Restaurant restaurant1 = new Restaurant();
        //Restaurant restaurant2 = new Restaurant("");
        //Restaurant restaurant3 = new Restaurant("","");
        
    }
}
?
class Restaurant{
    
    String name;
    String addr;
    
    {
        // 随着对象的创建执行,每创建一个对象就执行一次,可以把构造方法中相同的部分写在此处,在此完成构造方法的初始化
        // 加载时间早于构造方法,加载时间和实例属性部分先后,谁在前谁先上
        System.out.println("几位爷里面请!!!");
        System.out.println(name + "==" + addr);
    }
    
    public Restaurant() {
        super();
        System.out.println("空参构造方法。。。");
    }
    
    public Restaurant(String addr) {
        super();
        this.addr = addr;
        System.out.println("1参构造方法。。。");
    }
?
    public Restaurant(String name, String addr) {
        super();
        this.name = name;
        this.addr = addr;
        System.out.println("2参构造方法。。。");
    }
    
}

7.3 静态代码块（掌握）

7.3.1 定义

• 使用static修饰的代码块，定义在类中方法外，和变量、动态代码块的位置一样

• 类第一次加载的时候调用，整个程序周期中只执行一次

• 可以用来加载驱动等只执行一次的操作

7.3.2 案例

package com.qf.block;
?
public class Demo03 {
    public static void main(String[] args) {
        System.out.println("开始创建对象");
        Mouse mouse1 = new Mouse();
        Mouse mouse2 = new Mouse();
        Mouse mouse3 = new Mouse();
        Mouse mouse4 = new Mouse();
    }
}
?
class Mouse{
    // 属性
    String brand;
    String color;
    
    {
        System.out.println("我是动态代码块...");
    }
    
    static {
        System.out.println("我是静态代码块================");
    }
    
    // 构造方法
    public Mouse() {
        super();
    }
?
    public Mouse(String brand) {
        super();
        this.brand = brand;
    }
?
    public Mouse(String brand, String color) {
        super();
        this.brand = brand;
        this.color = color;
    }
}

7.4 同步代码块（了解）

• 多线程中会讲解

•  

Java修饰符

原文：https://www.cnblogs.com/tree-hole/p/13697222.html