面向对象的深刻分析

目录

一、面向对象 

二、概念层、逻辑层、物理层

三、初始化规则

四、实例化对象语法

五、使用属性的语法

六、this的作用

七、普通方法和静态方法的区别

八、static的理解

九、代码分析加强理解

---

一、面向对象

        面向对象程序设计以对象为核心，该方法认为程序由一系列对象组成。 类是对现实世界的抽象，包括表示静态属性的数据和对数据的操作，对象是类的实例化。

二、概念层、逻辑层、物理层

        1.概念层：（现实生活中） 万物皆对象

        2.逻辑层：（对于开发人员）对现实生活中一类有形或者无形的概念的特征抽取特征表现为属 性，对其行为的抽取表现为方法，对象的职责不同，方法也就不同。

        3.物理层：（相对于内存空间）对象在堆区、对象在堆上是具体怎么存储的、对象是怎么被构建出来的

三、初始化规则

        局部变量不能被static修饰（static永远是相对于类而言的）

        局部变量没有初始值，如果直接使用会导致编译不通过

public class{
    public static void main(String[] args){
        String s;
        System.out.print(s);
    }
}

        静态变量拥有初始值（0的“改写”），boolea的初始值是false

四、实例化对象语法

        new 类名（要调用的构造方法的参数列表）

        Person p=new Person（String name，int age）；

        当一个对象被实例化，其静态变量也会初始化或赋值

        实例化大体上有三个步骤：

        1.通过类中的信息，计算内存的大小（隐含用到了类）在内存（堆区域）由JVM分配空间 把 这段内存区域，全部用0进行初始化（表现为属性的默认值） 

        2.执行对象的初始化过程   调用初始化语句 对象实例完成

        3.引用赋值                                             

五、使用属性的语法

        当成功实例化一个对象，你便可以使用其中的属性，例如：

        p.name      p.age       this.name    this.age

        当然，如果这些属性原本是被private修饰的，那你调用就需要get set方法，根据权限可以自由设置

六、this的作用

        1.在类的内部（构造方法和实例方法），是一个引用，代表指向当前对象的引用

        2.在构造方法中调用本类中的其他构造方法！this必须出现在最前面！

七、普通方法和静态方法的区别

        

        1.静态方法（类方法） 加static修饰    不能访问属性，不可以使用this

        2.普通方法（实例方法）   不加static     可以访问属性，可以使用this

 八、static的理解

        加了static之后，只和类有关，和本类的对象无关

        反之，不加static和本类的对象息息相关

        

 九、代码分析加强理解

        1.阅读如下代码。 请问，对语句行 test.hello(). 描述正确的有（）

        

package NowCoder;
class Test {
	public static void hello() {
	    System.out.println("hello");
	}
}
public class MyApplication {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test test=null;
		test.hello();
	}
}

                             

A.能编译通过，并正确运行

B.因为使用了未初始化的变量，所以不能编译通过

C.以错误的方式访问了静态方法

D.能编译通过，但因变量为null，不能正常运行

分析：由于hello()是个静态方法，所以在执行是自动将test对象转为Test,从而调用Test.hello()。与test是不是Null无关，因此程序可以正常运行！反之，如果hello是实例方法，那么在调用hello()的时候会出现java.lang.NullPointerException

        2.下面代码的运行结果是（）

public static void main(String[] args){

  String s;

  System.out.println("s="+s);

}

A.代码编程成功，并输出”s=”

B.代码编译成功，并输出”s=null”

C.由于String s没有初始化，代码不能编译通过。

D.代码编译成功，但捕获到NullPointException异常

分析：s作为一个局部变量，没有默认值，此时main方法使用到了s，编译无法通过

3.如下代码的输出结果是什么？

public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
public static void main(String args[]){
    Test test = new Test(); 
    test.aMethod(); 
    int j = test.aMethod();
    System.out.println(j);
    } 
}

A.0

B.1

C.2

D.编译失败

分析：我们提到过static是与类有关的，它不能用于修饰局部变量，所以编译无法通过。

4.当你编译和运行下面的代码时，会出现下面选项中的哪种情况？

public class Pvf{
    static boolean Paddy;
    public static void main(String args[]){
        System.out.println(Paddy);
    }
}

A.编译时错误

B.编译通过并输出结果false

C.编译通过并输出结果true

D.编译通过并输出结果null

分析：我们上边提到过，静态变量拥有初始值，boolean类型的初始值是false

最后，附上一个Time类的练习，属性是时，分，秒。方法为前进一秒和后退一秒

package Practice1125;

public class Time {
    private int hour;
    private int minute;
    private  int second;
    public Time(int hour,int minute,int second){
        if (!checkHour(hour)){
            throw new RuntimeException("时应处于1-24");
        }
        if (!checkMinute(minute)){
            throw new RuntimeException("分应处于1-60");
        }
        if (!checkSecond(second)){
            throw new RuntimeException("秒应处于1-60");
        }
        this.hour=hour;
        this.minute=minute;
        this.second=second;
    }

    private static boolean checkSecond(int second) {
        return second>=0&&second<60;
    }

    private static boolean checkMinute(int minute) {
        return minute>=0&&minute<60;
    }

    private static boolean checkHour(int hour) {
        return hour>=0&&hour<24;
    }
    public  void fastForwardOnesecond(){
        second++;
        if (second==60){
            minute++;
            second=0;
        }
        if (minute==60){
            hour++;
            minute=0;
        }
        if (hour==24){
            hour=0;
        }
        return;
    }
    public void stepBackforasecond(){
        second--;
        if (second<0){
            minute--;
            second=59;
        }
        if (minute<0){
            hour--;
            minute=59;
        }
        if (hour<0){
            hour=23;
        }
        return;
    }
    public String toString(){
        return String.format("%02d:%02d:%02d",hour,minute,second);
    }

}
public class TimeDemo {
    public static void main(String[] args) {
        Time time=new Time(14,47,0);
        for (int i=1;i<300;i++){
            time.fastForwardOnesecond();
            if (i%15==0){
                System.out.println(time.toString());
            }
        }
//        for (int i=0;i<300;i++){
//            time.stepBackforasecond();
//            if (i%15==0){
//                System.out.println(time.toString());
//            }
//        }

    }
}