关于java:面向对象的这些核心技术你掌握后包你面试无忧

面向对象简介

面向对象是绝对于面向过程来说的，面向过程是一种以“过程”为核心的编程思维，剖析出解决问题所需的步骤，而后用函数把这些步骤一步步的实现，应用的时候一个个顺次调用就好。而面向对象，是一种以“对象”为核心的编程思维，把问题看成一个个对象，通过对象的属性和行为，将问题解决的。面向过程强调的是模块化，而面向对象强调的是把事物对象化。

简单来说面向对象是以“对象”为根本单元构建零碎，对象是把数据和数据操作方法放在一起，作为一个相互依存的整体。把同类的对象形象出其共性，造成类。所以说类是对象的形象，对象是类具体化的体现（类是大范畴的，一个类能够有多个对象），类中的大多数数据只能通过本类的办法实现，类蕴含阐明和实现，阐明局部被外界所看到，通过简略的内部接口与外界进行分割；实现局部不被外界所看到，在外部通过不同办法的构建，实现不同的性能。对象与对象之间通过音讯进行沟通，程序流程由用户在应用中决定。

面向对象用以解决越来越简单的需要，进步了软件的重用性，灵活性和拓展性。

static 关键字

static 示意“动态”的意思，能够用来润饰成员变量和成员办法。static 的次要作用在于创立独立于具体对象的域变量或者办法 简略了解：被 static 关键字润饰的办法或者变量不须要依赖于对象来进行拜访，只有类被加载了，就能够通过类名去进行拜访，并且不会因为对象的屡次创立而在内存中建设多份数据。

1. 动态成员 在类加载时加载并初始化。
2. 无论一个类存在多少个对象 , 动态的属性, 永远在内存中只有一份(能够了解为所有对象专用)
3. 在拜访时：动态不能拜访非动态 , 非动态能够拜访动态 !
   静态方法调用的三种形式：
   1.new xx(). 动态 (); // 应用对象调用，不举荐
   2.xx. 动态(); // 类名调用，正规调用办法，举荐
   3. 动态(); // 本类的静态方法在本类调用，间接调用
   注意事项：
   在同包不同类调用的时候，能够间接 类名. 办法 () 调用，无需创建对象。
   在不同包调用的时候，须要引包再调用。

代码示例：

package com.vedio.highobject;

public class Pool {
    public static int water=0;// 动态变量

    public static void outlet() {// 放水
        if(water>=2) {water=water-2;}else {water=0;}
    }

    public static void inlet() {// 进水
        water=water+3;
    }

    public static void main(String[] args) {System.out.println("水池的水量："+water);
        System.out.println("水池注水两次。");
        Pool.inlet();
        Pool.inlet();
        System.out.println("水池的水量："+water);
        System.out.println("水池放水一次。");
        Pool.outlet();
        System.out.println("水池的水量："+water);
    }
}

留神：在类中调用静态方法和静态方法时，须要应用类名. 变量名或类名. 办法名调用，在本类中调用静态方法和静态方法时，能够不加类名。

instanceof 关键字

只有存在继承关系，能力应用 instanceof 关键字，否则会报错

代码示例：

// 只有存在继承关系，能力应用 instanceof 关键字，否则会报错
public class Computer {// 电脑类
    public static void main(String[] args) {Pad ipad=new Pad();
        LenovoPad lenovoPad=new LenovoPad();
        System.out.println("Pad 是否继承自电脑?"+(ipad instanceof Computer));
        System.out.println("LenovoPad 是否继承自 Pad?"+(lenovoPad instanceof Pad));
        System.out.println("Pad 是否继承自 LenovoPad?"+(ipad instanceof LenovoPad));
       // System.out.println("Pad 是否继承自人类?"+(ipad instanceof Person));//ipad 与 Person 这个类没有任何的继承关系
    }
}

class Pad extends Computer{// 平板电脑}
class LenovoPad extends Pad{// 联想平板电脑}

public class Person {public Person(String name){System.out.println("您好，我叫"+name);
    }
}

ipad 和 Person 两个类没有任何继承关系，所以应用 instanceof 时，会间接报错。

euqals()办法

查看 equals()源码，如下

public boolean equals(Object obj) {return (this == obj);
    }

所以在 object 类中 equals 办法只能用来比拟地址是否一样，与 == 作用一样。但当咱们能够本人重写 equals 办法，使之满足咱们的需要。

比方咱们定义一个 Person 类，只有 id 和 name 都一样时，才确定他们是同一个人。代码示例：

package com.vedio.highobject;

public class Person {
    String name;
    String id;

    public boolean equals(Person p) {return this.name.equals(p.name)&&this.id.equals(p.id);
    }
}

package com.vedio.highobject;

public class Demo1 {public static void main(String[] args) {Person p1=new Person();
       Person p2=new Person();
       Person p3=new Person();

       p1.name="小明";
       p1.id="123";

       p2.name="小红";
       p2.id="123";

       p3.name="小明";
       p3.id="123";

       System.out.println(p1.equals(p2));
       System.out.println(p1.equals(p3));
       System.out.println(p2.equals(p3));
    }
}

能够察看到，只有 id 和 name 齐全一样是，才为 true。通过重写 equals 办法，满足了咱们的需要。

equals 与 == 的区别

String 能够应用 equals 比拟地址是因为它重写了 equals 办法
查看 String 对 equals 办法的重写源码，如下：

    public boolean equals(Object anObject) {if (this == anObject) {return true;}
        if (anObject instanceof String) {String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }

equals 是判断两个变量或者实例指向同一个内存空间的值是不是雷同，而 == 是判断两个变量或者实例是不是指向同一个内存空间，
举个艰深的例子来说，== 是判断两个人是不是住在同一个地址，而 equals 是判断同一个地址里住的人是不是同一个
代码示例：

package com.vedio.highobject;

public class Demo2 {public static void main(String[] args) {String s1=new String("123");
        String s2=new String("123");
        System.out.println(s1.equals(s2));
        System.out.println(s1==s2);
        String s3="123";
        String s4="123";
        System.out.println(s3.equals(s4));
        System.out.println(s3.equals(s1));

    }
}

toString()办法

package com.object.high;

// 所有类的父类 --Object 类
// 在 Java 中，所有的类都间接或间接继承了 java.lang.Object 类
// 因为所有的类都是 Object 类的子类，所以任何类都能够重写 Object 类中的办法

public class Hello {// 重写 toString()办法
    public String toString(){return "Say \""+getClass().getName()+"\" to Java";//getClass().getName()获取类的名称}

    public static void main(String[] args) {System.out.println(new Hello());// 当打印某个类对象时，将主动调用重写的 toString()办法}
}

最初

感激你看到这里，文章有什么有余还请斧正，感觉文章对你有帮忙的话记得给我点个赞，每天都会分享 java 相干技术文章或行业资讯，欢送大家关注和转发文章！