Java面向对象详解-下

一、 static

static:静态的，可以用来修饰属性、方法、 代码块（或初始化块）、 内部类
static修饰属性（类变量）:
- 由类创建的所有的对象，都共用这一个属性
- 当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）
- 类变量随着类的加载而加载的，而且独一份
- 静态的变量可以直接通过“类.类变量”的形式来调用
- 类变量的加载是要早于对象 。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。
- 类变量存在于静态域中。
static修饰方法（类方法）:
- 随着类的加载而加载，在内存中也是独一份
- 可以直接通过“类.类方法”的方式调用
- 内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法
- 静态的方法内是不可以有this或super关键字的！
- 静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构
开发中，如何确定一个属性是否要有声明为static的？
- 属性可以被多个对象共享的，不会随着对象的不同而不同
开发中，如何确定一个方法是否要有声明为static的？
- 操作静态属性的方法通常也是静态的
- 工具类中对方法通常也为static的

public class TestCircle {
    public static void main(String[] args) {
        Circle c1 = new Circle();
        Circle c2 = new Circle(2.3);
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(Circle.getTotal());
    }
}

class Circle{
    private double radius;
    private static String info = "我是一个圆";
    private int id;//编号
    private static int init = 1001;//控制每个对象的id
    private static int total = 0;//记录创建了多少个对象

    public Circle(){
        this.id = init++;
        total++;
    }
    public Circle(double radius){
        this.radius = radius;
        this.id = init++;
        total++;
    }



    public double getRadius() {
        return radius;
    }
    public void setRadius(double radius) {
        this.radius = radius;
    }
    public static String getInfo() {
        return info;
    }
    public static void setInfo(String info) {
        Circle.info = info;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public static int getTotal() {
        return total;
    }
    public static void setTotal(int total) {
        Circle.total = total;
    }
    @Override
    public String toString() {
        return "Circle [radius=" + radius + ", id=" + id + "]";
    }
    public static void show(){
        System.out.println(Circle.info);
    }

    public void desc(){
        System.out.println(this.info);
    }

}

二、单例设计模式

解决的问题：如何只让设计的类只能创建一个对象
如何实现：饿汉式 & 懒汉式

1. 饿汉式1

class Bank{
    //1.私有化构造器
    private Bank(){}
    //2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
    //4.要求此对象也为static的
    private static Bank instance = new Bank();
    //3.此公共的方法，必须为static 
    public static Bank getInstance(){
        return instance;    
    }
}

2. 饿汉式2

class Bank{
    //1.私有化构造器
    private Bank(){}
    //2.创建类的对象，同时设置为private的，通过公共的来调用，体现封装性
    //4.要求此对象也为static的
    private static Bank instance = null;
    static{
        instance  = new Bank(); 
    }
    //3.此公共的方法，必须为static  
    public static Bank getInstance(){
        return instance;    
    }
}

3. 懒汉式

class Bank{
    private Bank(){}

    private static Bank instance = null;

    public static Bank getInstance(){
        if(instance == null){//可能存在线程安全问题的！
            instance = new Bank();      
        }   
        return instance;
    }
}

三、main()方法

public static void main(String[] args){
     //方法体     
}

//1.main()是一个方法，是主方法，为程序的入口
//2.权限修饰符：public protected 缺省 private ---面向对象的封装性
//3.对于方法来讲：static final abstract 
//4.方法的返回值：void /  具体的返回值类型（基本的数据类型 & 引用数据类型），方法内部一定要有return
//5.方法名：命名的规则：xxxYyyZzz。给方法命名时，要见名之意
//6.形参列表：同一个方法名不同的形参列表的诸多个方法间构成重载。   形参 & 实参---方法的参数传递机制：值传递
//7.方法体：方法定义的是一种功能，具体的实现由方法体操作。

四、代码块

代码块：是类的第4个成员 { }
作用：用来初始化类的属性
分类：只能用static来修饰。
静态代码块：
- 里面可以有输出语句
- 随着类的加载而加载并且执行，而且只被加载一次
- 多个静态代码块之间按照顺序结构执行
- 静态代码块的执行要早于非静态代码块的执行。
- 静态的代码块中只能执行静态的结构(类属性，类方法)
非静态代码块：
- 可以对类的属性(静态的 & 非静态的)进行初始化操作，同时也可以调用本类声明的方法(静态的 & 非静态的)
- 里面可以有输出语句
- 一个类中可以有多个非静态的代码块，多个代码块之间按照顺序结构执行
- 每创建一个类的对象，非静态代码块就加载一次。
- 非静态代码块的执行要早于构造器
关于属性赋值的操作：
- 默认的初始化
- 显式的初始化或代码块初始化(此处两个结构按照顺序执行)
- 构造器中；
- 以上是对象的属性初始化的过程------
- 通过方法对对象的相应属性进行修改

1. 常见问题

总结：由父及子，静态先行

class Root{
    static{
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }
    public Root(){
        super();
        System.out.println("Root的无参数的构造器");
    }
}
class Mid extends Root{
    static{
        System.out.println("Mid的静态初始化块");
    }
    {
        System.out.println("Mid的普通初始化块");
    }
    public Mid(){
        super();
        System.out.println("Mid的无参数的构造器");
    }
    public Mid(String msg){
        //通过this调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数构造器，其参数值："
            + msg);
    }
}
class Leaf extends Mid{
    static{
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }   
    public Leaf(){
        //通过super调用父类中有一个字符串参数的构造器
        super("尚硅谷");
        System.out.println("Leaf的构造器");
    }
}
public class LeafTest{
    public static void main(String[] args){
        new Leaf(); 
        System.out.println();
        new Leaf();
    }
}





package com.atguigu.java3;

class Father {
    static {
        System.out.println("11111111111");
    }
    {
        System.out.println("22222222222");
    }

    public Father() {
        System.out.println("33333333333");

    }

}

public class Son extends Father {
    static {
        System.out.println("44444444444");
    }
    {
        System.out.println("55555555555");
    }
    public Son() {
        System.out.println("66666666666");
    }


    public static void main(String[] args) { // 由父及子 静态先行
        System.out.println("77777777777");
        System.out.println("************************");
        new Son();
        System.out.println("************************");
        new Son();
        System.out.println("************************");
        new Father();
    }

}

五、final关键词

final:最终的，可以用来修饰类、属性、方法

final修饰类：这个类就不能被继承。如：String类、StringBuffer类、System类
final修饰方法：不能被重写。如：Object类的getClass()
final修饰属性：此属性就是一个常量，一旦初始化后，不可再被赋值。 习惯上，常量用大写字符表示
此常量在哪里赋值： ①此常量不能使用默认初始化 ②可以显式的赋值、代码块、构造器。
变量用static final修饰：全局常量。比如：Math 类的PI

class D{
    final int I = 12;
    final double PI;
    final String NAME;

    public void m1(){
        System.out.println(I);
//      I = 10;

    }
    {
        PI = 3.14;
    }

    public D(){
        NAME = "DD";
    }
    public D(String name){
        this();
        //NAME = name;
    }
}

六、抽象 abstract

abstract：抽象的，用来修饰类、方法

abstract修饰类：抽象类
- 不可被实例化
- 抽象类有构造器 (凡是类都有构造器)，便于子类实例化时调用
- 抽象方法所在的类，一定是抽象类 。
- 抽象类中可以没有抽象方法。
- 当我们设计一个类，不需要创建此类的实例时候，就可以考虑将其设置为抽象的，由 其子类实现这个类的抽象方法以后，就行实例化
abstract修饰方法：抽象方法
- 格式：没有方法体，包括{}.如： public abstract void eat();
- 抽象方法只保留方法的功能，而具体的执行，交给继承抽象类的子类，由 子类重写此抽象方法 。
- 若子类继承抽象类，没有重写所有的抽象方法，意味着此类中仍有抽象方法，则此类必须声明为抽象的

1. 模板方法设计模式

//模板方法设计模式
public class TestTemplate {
    public static void main(String[] args) {
        new SubTemplate().spendTime();
    }
}

abstract class Template {

    public abstract void code();

    public void spendTime() {
        long start = System.currentTimeMillis();

        this.code();

        long end = System.currentTimeMillis();
        System.out.println("花费的时间为：" + (end - start));
    }
}

class SubTemplate extends Template {

    public void code() {
        boolean flag = false;
        for(int i = 2;i <= 10000;i++){
            for(int j = 2;j <= Math.sqrt(i);j++){
                if(i % j == 0){
                    flag = true;
                    break;
                } 
            }
            if(!flag){
                System.out.println(i);
            }
            flag = false;
        }
    }
}

2. 抽象类的应用

//抽象类的应用：模板方法的设计模式
public class TemplateMethodTest {

    public static void main(String[] args) {
        BankTemplateMethod btm = new DrawMoney();
        btm.process();

        BankTemplateMethod btm2 = new ManageMoney();
        btm2.process();
    }
}
abstract class BankTemplateMethod {
    // 具体方法
    public void takeNumber() {
        System.out.println("取号排队");
    }

    public abstract void transact(); // 办理具体的业务 //钩子方法

    public void evaluate() {
        System.out.println("反馈评分");
    }

    // 模板方法，把基本操作组合到一起，子类一般不能重写
    public final void process() {
        this.takeNumber();

        this.transact();// 像个钩子，具体执行时，挂哪个子类，就执行哪个子类的实现代码

        this.evaluate();
    }
}

class DrawMoney extends BankTemplateMethod {
    public void transact() {
        System.out.println("我要取款！！！");
    }
}

class ManageMoney extends BankTemplateMethod {
    public void transact() {
        System.out.println("我要理财！我这里有2000万美元!!");
    }
}

七、接口 interface

接口（interface）是与类并行的一个概念

接口可以看做是一个 特殊的抽象类 。 是常量(public static final 可以省略)与抽象方法的一个集合，不能包含变量、一般的方法。
接口是没有构造器的
接口定义的就是一种功能。 此功能可以被类所实现（implements） 。
比如：class CC extends DD implements AA
实现接口的类，必须要重写其中的所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类
类可以实现多个接口。----java 中的类的继承是单继承的
接口与接口之间也是继承的关系，而且可以实现多继承

5,6描述的是java中的继承的特点。

接口与具体的实现类之间也存在多态性

1. 接口的使用

接口使用上也满足多态性
接口，实际上就是定义了一种规范
面向接口编程

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

        Computer com = new Computer();
        //1.创建了接口的非匿名实现类的非匿名对象
        Flash flash = new Flash();
        com.transferData(flash);

        //2. 创建了接口的非匿名实现类的匿名对象
        com.transferData(new Printer());

        //3. 创建了接口的匿名实现类的非匿名对象
        USB phone = new USB(){

            @Override
            public void start() {
                System.out.println("手机开始工作");
            }

            @Override
            public void stop() {
                System.out.println("手机结束工作");
            }

        };
        com.transferData(phone);


        //4. 创建了接口的匿名实现类的匿名对象

        com.transferData(new USB(){
            @Override
            public void start() {
                System.out.println("mp3开始工作");
            }

            @Override
            public void stop() {
                System.out.println("mp3结束工作");
            }
        });
    }
}

class Computer{

    public void transferData(USB usb){//USB usb = new Flash();
        usb.start();

        System.out.println("具体传输数据的细节");

        usb.stop();
    }


}

interface USB{
    //常量：定义了长、宽、最大最小的传输速度等

    void start();

    void stop();

}

class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开启工作");
    }

    @Override
    public void stop() {
        System.out.println("U盘结束工作");
    }

}

class Printer implements USB{
    @Override
    public void start() {
        System.out.println("打印机开启工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机结束工作");
    }

}

2. 工厂方法的设计模板

//接口的应用：工厂方法的设计模式
public class TestFactoryMethod {
    public static void main(String[] args) {
        IWorkFactory i = new StudentWorkFactory();
        i.getWork().doWork();

        IWorkFactory i1 = new TeacherWorkFactory();
        i1.getWork().doWork();
    }
}

interface IWorkFactory{
    Work getWork();
}
class StudentWorkFactory implements IWorkFactory{

    @Override
    public Work getWork() {
        return new StudentWork();
    }

}
class TeacherWorkFactory implements IWorkFactory{

    @Override
    public Work getWork() {
        return new TeacherWork();
    }

}

interface Work{
    void doWork();
}

class StudentWork implements Work{

    @Override
    public void doWork() {
        System.out.println("学生写作业");
    }

}
class TeacherWork implements Work{

    @Override
    public void doWork() {
        System.out.println("老师批改作业");
    }
}

3. 代理模式

//接口的应用：代理模式（静态代理）
public class TestProxy {
    public static void main(String[] args) {
        Object obj = new ProxyObject();
        obj.action();
    }
}

interface Object{
    void action();
}
//代理类
class ProxyObject implements Object{
    Object obj;

    public ProxyObject(){
        System.out.println("代理类创建成功");
        obj = new ObjctImpl();
    }

    public void action(){
        System.out.println("代理类开始执行");
        obj.action();
        System.out.println("代理类执行结束");
    }
}
//被代理类
class ObjctImpl implements Object{

    @Override
    public void action() {
        System.out.println("=====被代理类开始执行======");
        System.out.println("=====具体的操作======");
        System.out.println("=====被代理类执行完毕======");

    }

}

4. 问题

interface A {
    int x = 0;
}

class B {
    int x = 1;
}

class C extends B implements A {
    public void pX() {
        //编译不通过。因为x是不明确的
        // System.out.println(x);
        System.out.println(super.x);//1
        System.out.println(A.x);//0
    }

    public static void main(String[] args) {
        new C().pX();
    }
}

5. Java8新特性

八、内部类

Java中允许将一类A声明在类B中，则类A就是内部类

1. 成员内部类(静态、非静态)

作为一个类
- 类内可以定义属性、方法、构造器
- 可以被final修饰，表示此类不能继承，也就是不适用final，就可以被继承
- 可以被abstract修饰
作为外部类的
- 调用外部类的结构
- 可以被static修饰
- 可以被4种不同的权限修饰

局部内部类(方法内、代码块、构造器中)

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

        //创建Dog实例(静态的成员内部类):
        Person.Dog dog = new Person.Dog();
        dog.show();
        //创建Bird实例(非静态的成员内部类):
//      Person.Bird bird = new Person.Bird();//错误的
        Person p = new Person();
        Person.Bird bird = p.new Bird();
        bird.sing();

        System.out.println();

        bird.display("黄鹂");

    }
}


class Person{

    String name = "小明";
    int age;

    public void eat(){
        System.out.println("人：吃饭");
    }


    //静态成员内部类
    static class Dog{
        String name;
        int age;

        public void show(){
            System.out.println("卡拉是条狗");
//          eat();
        }

    }
    //非静态成员内部类
    class Bird{
        String name = "杜鹃";

        public Bird(){

        }

        public void sing(){
            System.out.println("我是一只小小鸟");
            Person.this.eat();//调用外部类的非静态属性
            eat();
            System.out.println(age);
        }

        public void display(String name){
            System.out.println(name);//方法的形参
            System.out.println(this.name);//内部类的属性
            System.out.println(Person.this.name);//外部类的属性
        }
    }


    public void method(){
        //局部内部类
        class AA{

        }
    }

    {
        //局部内部类
        class BB{

        }
    }

    public Person(){
        //局部内部类
        class CC{

        }
    }

}

2. 注意

package com.atguigu.java;

public class InnerClassTest {
    /*
     * 在局部内部类声明的方法中（比如：show）如果调用局部内部类所声明的方法(比如：method)中的局部变量(比如：num)的话,
     * 要求此局部变量声明为final的。
     * 
     * jdk 7及之前版本：要求此局部变量显式的声明为final的
     * jdk 8及之后的版本：可以省略final的声明
     * 
     */
    public void method(){
        //局部变量
        int num = 10;

        class AA{   
            public void show(){
//              num = 20;
                System.out.println(num);

            }   
        }   
    }
}

原文链接：https://www.cnblogs.com/mengd/p/13281626.html