忆Java基础知识之——Java语言介绍与运算符和流程

 

Java语言是完全面向对象的程序设计语言，它的所有内容都包含在类中。Java中的类与基本类型在本质上是一样的，都是对某一具有相同特性的事物的抽象。例如基本类型int就是对在一定范围内的整数集的一个抽象。而String类就是对字符串集的抽象。Java中的普通类都可以生成对象，对象是类的实现，也可以说类是实现对象的蓝图，何为对象，万物皆为对象。每个对象都有三个特性即标识，状态，接口。每个类生成的所有对象都可以由标识区分，而且都有自己特定的状态，接口是对象内部或与其他对象通信的方式。Java语言面向对象的三大基石分别为封装，继承，多态。
在编写Java代码时，一般首先实现类，然后再使用这些类创建对象，最后通过对象之间的通信来完成所要实现的任务。类主要由实例域（字段）与方法（C语言中称为函数）组成。构造器是类中的一种特殊方法。用来初始化对象。构造器的名字与类名相同，由于Java中可以由类来创建不同方式的对象，故构造器拥有不同类型的传递参数。但构造器的名字却与类名相同。这就需要使用重载技术。重载就是名称相同而传递参数类型不同的方法。不光构造器可以使用重载，类中的其他方法也可以是用重载。重载只可以使用参数类型来区分，就算如下例中的两个他么也是重载关系。
    void test(String str,int n)... {
        System.out.println(str + n);
}
     void test(int n,String str)... {
        System.out.println(str + n);
}
Java中this关键字有两种使用方法，一是用来表示调用方法或实例域的那个对象，另外一种使用方法是在以个构造器中调用另外一个重载了的构造器，注意此时必须在构造器中的第一行。例如
public class ThisTest... {
        ThisTest(String str)...{
        System.out.println(str);
        }
        ThisTest(String str,int n)...{
            this(str);
            System.out.println(str + n);
        }
        
        public static void main(String[] args)...{
            ThisTest t = new ThisTest("hello ",6);
        }
}     
显示结果为：hello
hello 6
在上面的例子中我们用到了这样一句：
         public static void  main(String[] args)
这个main方法是J2SE应用程序的入口，所有的J2SE应用程序都从这个方法开始运行。现在先来介绍一下static关键字，后面再来介绍main方法与初始化方面的知识。
    static关键字可以用在方法与实例域前面。当static用于实例域时，表示此实例域是静态的，即只能赋值一次。当static用于方法时，表示此方法是静态方法。一般我们将静态实例域与静态方法称为类实例域与类方法。因为他们不需要创建对象就可以直接由类名调用。例如：
    class StaticATest... {
     StaticATest()...{
         System.out.println("StaticATest()");
    }
    
    void test()...{
        System.out.println("StaticATest.Test()");
    }
}

class StaticBTest... {
    static StaticATest st = new StaticATest();
    static void test()...{
        System.out.println("StaticATest.Test()");
    }
}

public class StaticTest... {
    public static void main(String[] args)...{
        StaticBTest.test();
        StaticATest t = StaticBTest.st;
        t.test();
    }
}
    现在来介绍封装，什么是封装？在解释这个概念前我们先来认识一下包与可见权限。包是由package关键字定义的，创建包的主要用途是管理命名。Java语言中有四种可见权限，这四种可见权限分别是：
（a）     public ：表示在整个Java中都可以见（使用）。
（b）    private ：表示只可在类中可见（使用）。
（c）    protected :表示在包中可见（使用）且在子类中也可见（使用）。
（d）    default （默认）：只可在包中使用（可见）。
现在我们来解释封装的概念，封装其实就是把类中一些实例域或方法隐藏起来，不让外部直接访问到这些内容。具体操作就是将类中所有的实例域都定义为private，并且为每个实例域创建一个public的方法，使外部可以调用它。将不对外的方法全部使用private。
类的扩展有两种方法，一种是组合，另外一种是继承。组合即将一个对象作为另外一个类的实例域。继承即用一个新类来扩展另外一个类，这个新类被称为子类，被用来扩展的那个类称为父类。子类拥有父类除private定义外的所有实例域和方法。继承需要使用关键字extends来扩展新类。若父类中有一个非private的方法，此时我们在子类中定义一个同样的方法，则子类的这个方法覆盖了父类的那个方法。覆盖父类方法后的可见性不可低于父类方法。在子类覆盖父类的那个方法中调用父类的那个被覆盖的方法，我们需要使用super关键字。且关键字必须放在方法作用域的第一行。Java语言只可以单继承。且Java语言中的所有类都用一个共同父类Object，这个父类有以下几个重要方法equals()，toString()等方法。其中equals()方法是比较两个对象的内容是否相等。在类库中这个方法大部分是这样实现的，但是它的默认方式却是比较两个对象的引用。故在创建新类时要覆盖此方法以达到所需要应用目的。toString()方法是返回类中各实例域的信息。在创建自己的类时也要覆盖此方法。抽象类是一种不可以创建对象的类，此类只可以做为继承的父类。一般将公共的信息作为此类的元素。抽象类中还可以定义抽象方法，若继承抽象类的类中用抽象方法，则此类仍然为抽象类。抽象类由abstract关键字定义。
介绍完类的继承后，现在我们来了解一下类的初始化。类的初始化顺序一般为以下几步：
1 、    父类static实例域的初始化。
2 、    子类static实例域的初始化。
3 、    父类普通实例域按定义顺序进行初始化。
4 、    运行父类构造器。
5 、    子类普通实例域按定义顺序进行初始化。
6 、    运行子类构造器。
例如：
class FatherStaticTest... {
    FatherStaticTest()...{
        System.out.println("FatherStaticTest()");
    }
}

class FatherTest... {
    FatherTest()...{
        System.out.println("FatherTest()");
    }
}

class SonStaticTest... {
    SonStaticTest()...{
        System.out.println("SonStaticTest()");
    }
}

class SonTest... {
    SonTest()...{
        System.out.println("SonTest()");
    }
}

class FatherClass... {
    FatherClass()...{
        System.out.println("FatherClass()");
    }
    
    public static void Test()...{
        System.out.println("FatherClass.Test()");
    }

    private FatherTest ft = new FatherTest();
    private static FatherStaticTest fst = new FatherStaticTest();
}

class SonClass extends FatherClass... {
    SonClass()...{
        System.out.println("SonClass()");
    }
    
    private SonTest st = new SonTest();
    private static SonStaticTest sst = new SonStaticTest();
    
    public static void main(String[] args)...{
        System.out.println("main()");
        
        SonClass sc = new SonClass();
    }
}
    运行显示结果：FatherStaticTest()
SonStaticTest()
main()
FatherTest()
FatherClass()
SonTest()
SonClass()
static定义的内容仅在调用static实例域，调用static方法，创建对象时才被初始化。记住static方法是不能使用this关键字，即static方法中，不可使用对象。
     Java语言中还有一关键字也需要交代一下，那就是定义常量的final关键字，这个关键字在Java语言类中也有其他的含义，若在定义类时，在类名前加上final关键字，则此类不可以被继承。若类中一个方法前使用final关键字，则此方法不可以被覆盖。注意，使用private关键字的方法，自动将其设置为final。
     多态是Java面向对象的基石之一。何为多态，多态即子类的对象可以向上转型为其父类对象，但在实际应用中，又可以准确调用子类自己的方法。例如：
     abstract class Animal... {
    public void call()...{}
}

class Dog extends Animal... {
    Dog(String s)...{
        this.s = s;
    }
    public void call()...{
        System.out.println("Dog " + s<img src="">);
    }
    
    private String s;
}

class Cat extends Animal... {
    Cat(String s)...{
        this.s = s;
    }
    public void call()...{
        System.out.println("Cat " + s);
    }
    
    private String s;
}

public class AnimalTest... {
    public static void main(String[] args)...{
        Animal a1 = new Dog("汪汪");
        Animal a2 = new Cat("喵喵");
        
        a1.call();
        a2.call();
    }
}

    运行结果为：Dog 汪汪
Cat 喵喵
     Java语言值得我们使用的最重要一点就是垃圾处理机制，奶奶的，设计出Java语言的那位天才真的想的很周到，将很多的内容都交给了类库与Java虚拟机来完成，不过这也带来了一定的弊端，就是内存与速度。不过世界上也没有十全十美的东西。它所带来的好处也是多多的。不然他就不会这么流行。
到这里为止Java语言的基本内容可以说已经全部介绍完了。也
许有人会问接口，内部类等等，这些我认为已经算是高级的东西了。等下篇我在来介绍。