【学习笔记】java面向对象基础编程3

一. 对象块

代码如下:

 1 public class TestObject {
 2     int i;
 3     int j;
 4     {
 5         System.out.println("对象块执行....");
 6         this.i = 1;
 7         this.j = 99;
 8     }
 9     
10     public TestObject(){
11         System.out.println("构造函数执行.....");
12         System.out.println("i = " +i);
13         System.out.println("j = " +j);
14     }
15     
16     public static void main(String[] args){
17         TestObject test = new TestObject();
18         
19     }
20 }

执行结果:

对象块执行....
构造函数执行.....
i = 1
j = 99

如以上代码, 在4~8行中, 为对象块.
从执行结果可以看出, 对象块优于构造函数执行, 用于对成员变量进行初始化操作, 而且, 通过this可以看出, 在对象被创建的时候, 对象块就执行, 可见, 对象块是属于对象的.

 

二. 静态块

代码如下:

1 public class TestObject {
2     static{
3         System.out.println("静态块被加载...");
4     }
5     
6     public static void main(String[] args){
7         
8     }
9 }

运行结果:

静态块被加载...

为什么main函数为空, 也能显示出这个结果呢? 因为main函数是一个主入口, 而这个入口执行前, 要先加载类, 而静态块是属于类的, 所以在类被加载的时候, 静态块就被执行.
静态块一般只执行一次.

好处用法: 对于一些常用的初始化的东西, 在程序开始时就进行初始化操作.(利用了只执行一次, 并且优于main函数的特点)

 

三. 包 package

每个类都要放在包里， 规范起来。包的命名推荐使用公司名称。比如google.com 可以这样命名包 com.google.项目名称.模块名称

包是严格的按照系统分类的来的，这点很重要， 也就是说，包是一个文件夹，一级一级这样下去，最后子文件是类文件.

包的导入, 用import 包名;

注意：在包与包内的类之间进行相互调用的时候，就要用到import导入, 继承一个其他包的类, 也要这么做.

一个猫类 继承了动物类. 注意在类前面有import把动物类的包给导入. 如下:

package com.abc.one;
import com.abc.two.Animal;

public class Cat extends Animal {
    static{
        System.out.println("A cat");
    }
    
    public static void main(String[] args){
        Cat cat = new Cat();
        cat.mathod();
    }
}

 

动物类:

package com.abc.two;


public class Animal {
    public static void main(String[] args){
        System.out.println("动物类");
    }
    public void mathod(){
        System.out.println("动物方法");
    }
}

 

运行 Cat.java文件的结果为:

A cat
动物方法

 

包的创建:

 

 

两个不同包之间的调用, 用import包导入来实现.

 

四. 访问控制

建立一个包：

 

代码如下：

package com.abc.one;

public class Mathod2 {
    private int i;
    int j;
    protected int n;
    public int m;
}

package com.abc.one;

public class Mathod1 {
    public static void main(String[] args){
        Mathod2 ma2 = new Mathod2();
        System.out.println("无法打印出i， 因为i为私有类型，只有在本类中使用");
        System.out.println("打印出同一个包内其他类的frendly修饰符的j = "+ ma2.j);
        System.out.println("打印出同一个包内其他类的protected修饰符的n = "+ ma2.n);
        System.out.println("打印出同一个包内其他类的public修饰符的m = "+ ma2.m);
    }
}

 

运行结果：

无法打印出i， 因为i为私有类型，只有在本类中使用
打印出同一个包内其他类的frendly修饰符的j = 0
打印出同一个包内其他类的protected修饰符的n = 0
打印出同一个包内其他类的public修饰符的m = 0

 

五.方法重载

方法重载即指同一个类中可以有多个相同名称的方法,但是每个方法的参数不能相同(参数个数不同或者参数类型不同). 注意: 这里说明的是参数不同, 与其他如返回类型等等无关.

方法重载所带来的好处:

1.系统设计的类. 如System.out.println();就是一个系统设计的方法重载.

2.自己设计的类.

代码：

 1 package com.jfu.one;
 2 
 3 public class packAge {
 4     public static void packAgee(Object obj){
 5         System.out.println("执行Object方法");
 6     }
 7     public static void packAgee(String str){
 8         System.out.println("执行String方法");
 9     }
10     
11     public static void main(String[] args){
12         Object obj = null;
13         String str = null;
14         packAge pa = new packAge();
15         packAgee(obj);
16         packAgee(str);
17     }
18 }

 

执行结果： 

执行Object方法
执行String方法

 

注意点：在给出一个两个重载方方法都有的参数的时候，java虚拟机会把它给子类的重载函数。如上面，String 继承于 Object，所以调用的是String重载函数。如果没有任何关系的，由于不知道是哪一个，所以无法编译通过！

如下：

package com.jfu.one;

public class packAge {
    public static void packAgee(Object obj){
        System.out.println("执行Object方法");
    }
    public static void packAgee(String str){
        System.out.println("执行String方法");
    }
    
    public static void main(String[] args){
        Object obj = null;
        String str = null;
        packAge pa = new packAge();
        packAgee(obj);
        packAgee(str);
        packAgee(null);
    }
}

 

执行结果：

执行Object方法
执行String方法
执行String方法

请看下面的代码和注释：

package com.jfu.one;

public class packAge {
    public static void packAgee(Object obj){
        System.out.println("执行Object方法");
    }
    public static void packAgee(String str){
        System.out.println("执行String方法");
    }
    //这里StringBuffer 不是继承与Object的，和他们没有关系，它也有null
    //此时编译器无法识别，null是属于哪个重载方法的
    public static void packAgee(StringBuffer strb){
        System.out.println("执行StringBuffer方法");
    }
    
    public static void main(String[] args){
        Object obj = null;
        String str = null;
        packAge pa = new packAge();
        packAgee(obj);
        packAgee(str);
        packAgee(null); //报错！
    }
}