java进阶1-面向对象

final

不可改变

1. 被final修饰的变量是常量，必须赋值；
2. 被final修饰的方法，不能被重写；
3. 被final修饰的类，不能被继承；
4. 构造方法不能被final修饰，因为构造函数内在有不能被重写的性质，所以不能被final修饰。
5. 被final修饰的引用，不能再次被赋值，但该引用指向的对象可以被修改，就是说，对象的属性可以被修改。
6. 被final修饰的static变量或static语句，不能在类加载时初始化。

//final修饰的类不能被继承
 final class Father {
//    final修饰的变量必须赋值
    final String name = "xin";
//    final修饰的方法不能重写
    public final int qian(int age) {
        return age + 1;
    }
//    final不能修饰构造方法
    public Father(){

    }
}

抽象类

被abstract修饰
抽象方法没有方法体

1. 抽象类的设计目的就是把一些公用的属性，写在类中用于被子类继承，声明抽象方法，用于被实现类实现，抽象方法必须被实现，当然也可有普通方法，只不过抽象类中的普通方法，意义不大。
2. 抽象类不能被实例化
3. 抽象类不能被final修饰，因为被final类修饰的类不能被继承，这与抽象类可以被继承相矛盾。
4. 抽象方法不能被final修饰，因为抽象方法是要被子类实现的，也就是可以修改。
5. 抽象类可以更好的实现多态机制。

//抽象类
abstract class Diaodu {
    String name="dii";
//普通方法
    public void zhi() {
        System.out.println("zhihui");
    }
//    抽象方法
    public abstract void bai();
//    构造方法
    public Diaodu(){
    }
}

接口

1. 采用interface声明，在接口中只能声明抽象方法和常量
2. 接口中的方法都是抽象方法，默认用public abstract修饰，不能更改。
3. 接口中的变量都是常量，默认用public static final修饰，不能更改。
4. 接口不能被实例化，只用来实现，没有构造函数概念。
5. 接口之间可以继承。
6. 一个类可以实现多个类。
7. 接口中的方法必须被全部实现。

interface Bai {
//    抽象中的变量隐含用public static final修饰，子类不可修改
    String mao = "shide";

    public static final String hong = "honghoang";
    
    public abstract void fu();
    
//    抽象类中的方法都是抽象方法，子类必须全部实现。
    public String shui();
}

class Du implements Bai{
    public void fu() {
        System.out.println("nihao");
    }
    public String shui(){
        return "ccc";
    }
}

接口作用

1. 规范，明确了提供的服务
2. 解决多继承问题。
3. 多态

面向接口编程

Object

是所有类的根基类

tostring

返回该对象的字符串表示

finalize

垃圾回收器，也叫GC

尽快回收垃圾

System.gc
runtime.getRuntime().gc()

==

对于基本类型是值比较，对于对象是内存地址比较是否相等

equals

对于object 默认比较的是内存地址,注意String类型经过重写比较的是内容。对于基本类型无此方法。

包

important

常用宝

java.lang jdk标准包，无需导入
java.sql
java.util 工具包
java.IO 输入输出流

访问控制权限

private 同一个类中
default 同一个包中
public 任何
protected 子类

内部类

设计目的主要是为了实现多继承

实例内部类

1. 类中的普通类，内部类可以访问外部类的变量
2. 创建内部类实例，必须先创建外部类实例
3. 实例内部列持有外部类的引用，此时内部类如同外部类的一个变量
4. 实例内部类中的变量不能被static修饰，只能定义成员变量

public class Shilineibulei {
    public static void main(String[] args) {
        Out.Inner inner = new Out().new Inner();
        System.out.println(inner);
        System.out.println(inner.bai);
        System.out.println(inner.ri);
    }
}

class Out {
    String name = "shide";
    public void run() {
        System.out.println("de");
    }
//实例内部类
    class Inner {
        String bai = "bai1";
        String ri = name;
        public void mao() {
            System.out.println("mao1");
        }
    }
}

静态类

static修饰

1. 静态内部类中的静态变量可以直接访问外部类的静态变量，如要访问外部类实例变量，必须将外部类实例化
2. 创建内部类无需先创建外部类实例对象，
3. 静态内部类就如外部类中的静态变量和静态方法一样，内部类中static修饰的方法和变量也是在类加载时初始化，内部类中的实例变量也是要内部类实例化之后才能访问。

public class JingtaiNeibulei {
    public static void main(String[] args) {
//        创建内部类实例对象无需先创建外部类
        Qing.Han han = new Qing.Han();
//        可以直接访问内部类的静态变量，
        System.out.println(Qing.Han.wu);
//        访问内部类的实例变量
        System.out.println(han.wen);
//        调用静态方法
        Qing.Han.sun();
    }
}

class Qing{
    String huang = "huanghuang";
    static String shu = "shushu";
//静态内部类
    static class Han {
        static String wu = shu;
//        String cao = huang;
        String wen = "wenwen";

        public static void sun() {
            System.out.println("nihao");
        }
    }
}

局部内部类

1.方法中的内部类
2 .和内部类一样不能有静态成员
3. 局部变量必须用final修饰，可以隐含

public class JubuNbulei {
    int a = 100;

    public void run() {
        int b = 200;
        
        class Kan {
            int c = a;
            int d = b;
            int f = 30;
            final int g = 50;
        }

        Kan kan = new Kan();
        
        int tt = kan.f;
        System.out.println(kan.c);
        System.out.println(tt);
        System.out.println(kan.f);
    }


    public static void main(String[] args) {
        JubuNbulei jubu = new JubuNbulei();
        jubu.run();
    }
}

匿名内部类

可以new接口或抽象类，实际上是new了接口或抽象类的子类创建的对象，后面要实现抽象方法，实际上同时实现了抽象方法并创建了子类的实例对象。

public class NimingNeibulei {
    public static void main(String[] args) {
        NimingNeibulei niming = new NimingNeibulei();
        niming.huidiao(new Liu() {
            public void qu() {
                System.out.println("zhongzhong");
            }
        });

        niming.huidiao(new Son() {
            public void qu() {
                System.out.println("zhongzhong");
            }
        });
    }

        public void huidiao(Liu ll) {
            ll.qu();
        }
}

interface Liu {
    void qu();
}

abstract class Son implements Liu{

}