• 欢迎访问少将全栈,学会感恩,乐于付出,珍惜缘份,成就彼此、推荐使用最新版火狐浏览器和Chrome浏览器访问本网站。
  • 吐槽,投稿,删稿,交个朋友,商务沟通v:ai_draw
  • 如果您觉得本站非常有看点,那么赶紧使用Ctrl+D 收藏少将全栈吧

Java:Java快速入门

Java admin 9年前 (2015-10-04) 1891次浏览 已收录 3个评论 扫描二维码

你好,世界!

源代码组织方式

Java:Java快速入门

Java程序由package+class组成,package对应目录的相对路径,class对应文件,如

E:WorkspacesMyEclipse 10JavaStudysrccomhappyframeworkjavastudyhelloHello.java


先用sublime来写一个Hello.java

public final class hello {
 public static void main(String[] args) {
  System.out.println("hello!");
 }
}

Java:Java快速入门


Hello.java

package com.happyframework.javastudy.hello;
public final class Hello {
    public static void hello(){
        System.out.println("hello!");
    }
}

关于class有如下几点规则:

  1. 文件的名字必须和class的名字一致(public级别的class名字)。
  2. 文件必须只包含一个public访问基本的class(可以包含多个非public级别的class)。
  3. package名字必须和目录一致。

入口方法

App.java

public class App {
 public static void main(String[] args) {
  com.happyframework.javastudy.hello.Hello.hello();
 }
}

最终的项目结构

Java:Java快速入门

数据类型

8种原子类型

  1. 整数类型:byte、short、int和long。
  2. 小数类型:float和double。
  3. 字符类型:char。
  4. 布尔类型:bool。

除此之外的是interface、class和array。

小数类型的常量默认是double类型,声明float类型的常量需要使用F作为后缀。

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
            float age = 28.0F;
            System.out.println(age);
    }
}

运算符

  1. 算术运算符:+、-、*、/ 和 %,两个整数相除,结果还是整数。
  2. 赋值运算符:=、+=、-=、*=、/=、%=、&=、|=、~=、^=、<<=、>>= 、 >>>=、++ 和 –。
  3. 比较运算符:==、!=、<、<=、> 和 >=。
  4. 逻辑运算符:&&、|| 和 !。
  5. 位运算符:&、|、~、^、<<、>> 和 >>>。

字符串

String是拥有“值语义”的引用类型,字符串常量实现了“享元模式”,equals会按照内容进行比较,==按照地址比较。

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        String x = "乐意窝";
        String y = new String("乐意窝");
        System.out.println(x.equals(y)); // true
        System.out.println(x == y); // false
    }
}

为了高效的修改字符串Java引入了StringBuffer。

Java:Java快速入门

{
            StringBuffer sb = 
                    new StringBuffer()
                    .append("乐")
                    .append("意")
                    .append("窝");
            System.out.println(sb.toString());
        }

数组

声明语法

DataType[] name 或 DataType name[]。

初始化语法

DataType[] name = new DataType[length]。

DataType[] name = new DataType[] { element1, element2, …elementn }。

DataType[] name = { element1, element2, …elementn }。

Java:Java快速入门


public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        {
            String[] strs = { "乐", "意", "窝" };
            for (String item : strs) {
                System.out.print(item);
            }
        }
    }
}

多维数组

只有不等长多维数组DataType[][],没有DataType[xxx, xxx]。

控制结构

  1. 条件:if-else if-else、switch-case-default和三元运算符(?:)。
  2. 循环:while、do-while、for和foreach。
  3. Labeled block。
Java:Java快速入门

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        task: {
            int age = 25;
            System.out.println("start");
            if (age < 30) {
                break task;
            }
            System.out.println("end");
        }
    }
}

最近觉得label是个不错的东西,最起码多了一种选择。

方法

Java中所有的赋值和方法调用都是“按值“处理的,引用类型的值是对象的地址,原始类型的值是其自身。

Java支持变长方法参数。

Java:Java快速入门

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        print("乐意窝", "我乐意");
        print(new String[] { "乐意窝", "我乐意" });
    }
    private static void print(String... args) {
        for (String item : args) {
            System.out.println(item);
        }
    }
}


public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Point point = new Point(100);
        System.out.print(point);
    }
}
class Point {
    private int x = 0;
    private int y = 0;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public Point(int x) {
        this(x, x);
    }
    public String toString() {
        return "(x:" + this.x + ",y:" + this.y + ")";
    }
}

注意:调用自身的构造方法是用this(xxx,xxx,…)来完成,且必须位于第一行。

静态成员

Java中类似静态构造方法的结构,称之为:静态初始化代码块,与之对应的是实例初始化代码块,见下例:

Java:Java快速入门

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(Point.getValue());
        System.out.println(new Point());
    }
}
class Point {
    private static int value = 0;
    public static int getValue() {
        return value;
    }
    static {
        value++;
    }
    static {
        value++;
    }
    private int x = 0;
    private int y = 0;
    {
        this.x = 10;
    }
    {
        this.y = 10;
    }
    public String toString() {
        return "(x:" + this.x + ",y:" + this.y + ")";
    }
}

继承

继承使用 extends,抽象类和抽象方法使用abstract声明,向下转型使用 (ChildType)instance,判断是否是某个类型使用 instanceof,见下例:

Java:Java快速入门

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        printAnimal(new Animal());
        printAnimal(new Dog());
    }
    private static void printAnimal(Animal animal) {
        if(animal instanceof Dog){
            System.out.println("I am a " + (Dog) animal);
        }
        else
        {
            System.out.println("I am an " + animal);
        }
    }
}
class Animal {
    public String toString() {
        return "Animal";
    }
}
class Dog extends Animal {
    public String toString() {
        return "Dog";
    }
}

重写

Java中的重写规则比较灵活,具体如下:

  1. 除了 private 修饰之外的所有实例方法都可以重写,不需要显式的声明。
  2. 重写的方法为了显式的表达重写这一概念,使用 @Override进行注解。
  3. 重写的方法可以修改访问修饰符和返回类型,只要和父类的方法兼容(访问级别更高,返回类型更具体)。
  4. 可以使用final将某个方法标记为不可重写。
  5. 在构造方法中使用 super(xxx, xxx)调用父类构造方法,在常规实例方法中使用 super.method(xxx, xxx)调用父类方法。
  6. Java不支持覆盖(new)。

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal dog = new Dog();
        animal.say();
        dog.say();
        animal.eat(animal);
        dog.eat(dog);
        System.out.println(animal.info());
        System.out.println(dog.info());
    }
}
class Animal {
    private String name = "Animal";
    protected void say() {
        System.out.println("Animal" + " " + this.name);
    }
    public void eat(Animal food) {
        System.out.println("Animal eat " + food);
    }
    public Object info() {
        return "Animal";
    }
    @Override
    public String toString() {
        return "Animal";
    }
}
class Dog extends Animal {
    private String name = "Dog";
    @Override
    public final void say() {
        System.out.println("Dog" + " " + this.name);
    }
    @Override
    public final void eat(Animal food) {
        super.eat(food);
        System.out.println("Dog eated");
    }
    @Override
    public final String info() {
        return "Dog";
    }
    @Override
    public final String toString() {
        return "Dog";
    }
}


包的名字和项目路径下的目录路径相对应,比如:项目路径为:C:Study,有一个Java源文件位于:C:Studycom
happyframeworkstudyApp.java,那么App.java的包名字必须
为:com.happyframework.study,且 App.java
的第一行语句必须为:package com.happyframework.study。

Java支持三种导入语法:

  1. 导入类型:import xxx.xxx.xxxClass。
  2. 导入包:import xxx.xxx.xxx.*。
  3. 导入静态成员:import static xxx.xxx.*。
Java:Java快速入门

import static util.Helper.*;
public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        puts("乐意窝");
    }
}

访问级别

Java支持四种访问级别:public、private、protected 和 default(默认),类型和接口只能使用public 和 default,成员和嵌套类型可以使用所有,下面简单的解释一下 protected 和 default。

  • protected 修饰过的成员只能被自己、子类和同一个包里的(不包括子包)其他类型访问。
  • default 修改过的类型或成员只能被自己和同一个包里的(不包括子包)其他类型访问。

嵌套类

Java支持如下几种嵌套类:

  1. nested class,定义在类型内部的类型。

    1. static nested class,使用 static 声明的 nested class,static nested class 可以访问所有外部类的静态成员。
    2. inner class,没有使用 static 声明的 nested class,inner class 可以访问所有外部类的实例成员,inner class 不能定义静态成员。

代码示例

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();
        OuterClass.InnerClass inner = outer.new InnerClass();
        OuterClass.InnerClass.InnerInnerClass innerInner = inner.new InnerInnerClass();
        outer.show();
        inner.show();
        innerInner.show();
        OuterClass.StaticNestedClass staticNested=new OuterClass.StaticNestedClass();
        OuterClass.StaticNestedClass.StaticNestedNestedClass staticNestedNested=new OuterClass.StaticNestedClass.StaticNestedNestedClass();
        staticNested.show();
        staticNestedNested.show();
    }
}
class OuterClass {
    int x = 1;
    static int i = 1;
    void show() {
        System.out.println(x);
        System.out.println(i);
    }
    class InnerClass {
        int y = 2;
        void show() {
            System.out.println(x);
            System.out.println(y);
        }
        class InnerInnerClass {
            int z = 3;
            void show() {
                System.out.println(OuterClass.this.x);
                System.out.println(y);
                System.out.println(z);
            }
        }
    }
    static class StaticNestedClass {
        static int j = 2;
        void show() {
            System.out.println(i);
            System.out.println(j);
        }
        static class StaticNestedNestedClass {
            static int k = 3;
            void show() {
                System.out.println(i);
                System.out.println(j);
                System.out.println(k);
            }
        }
    }
}

特殊的inner class:local class

Java:Java快速入门

public class LocalClassExample {
    static String staticValue = "static value";
    String instanceValue = "instance value";
    public void test() {
        final String finalLocalValue = "final local value";
        class LocalClass {
            void test() {
                System.out.println(staticValue);
                System.out.println(instanceValue);
                System.out.println(finalLocalValue);
            }
        }
        LocalClass local = new LocalClass();
        local.test();
    }
}

除了inner class的规则之外,local class可以访问局部final变量,在Java8中有更多的改进。

特殊的local class:anonymous class

public class Program {
    /**
     * @param args
     */
    public static void main(String[] args) {
        execute(new Action() {
            @Override
            public void execute() {
                System.out.println("执行业务逻辑");
            }
        });
    }
    static void execute(Action action) {
        System.out.println("事物开始");
        action.execute();
        System.out.println("事物结束");
    }
}
interface Action {
    void execute();
}

常量

不废话了,直接看代码:

public final class Program {
    static final String STATIC_CONSTANTS = "STATIC_CONSTANTS";
    final String INSTANCE_CONSTANTS = "INSTANCE_CONSTANTS";
    public static void main(String[] args) {
        final String LOCAL_CONSTANTS = "LOCAL_CONSTANTS";
        System.out.println(STATIC_CONSTANTS);
        System.out.println(new Program().INSTANCE_CONSTANTS);
        System.out.println(LOCAL_CONSTANTS);
        new Program().test("PARAMETER_CONSTANTS");
    }
    public final void test(final String msg) {
        System.out.println(msg);
    }
}

有一点需要注意的是:只有一种情况Java的常量是编译时常量(编译器会帮你替换),其它情况都是运行时常量,这种情况是:静态类型常量且常量的值可以编译时确定。

接口

Java的接口可以包含方法签名、常量和嵌套类,见下例:

public final class Program {
    public static void main(String[] args) {
        Playable.EMPTY.play();
        new Dog().play();
    }
}
interface Playable {
    Playable EMPTY = new EmptyPlayable();
    void play();
    class EmptyPlayable implements Playable {
        @Override
        public void play() {
            System.out.println("无所事事");
        }
    }
}
class Dog implements Playable {
    @Override
    public void play() {
        System.out.println("啃骨头");
    }
}

枚举

Java枚举是class,继承自java.lang.Enum,枚举中可以定义任何类型可以定义的内容,构造方法只能是private或package private,枚举成员会被编译器动态翻译为枚举实例常量,见下例:

public final class Program {
    public static void main(String[] args) {
        System.out.println(State.ON);
        System.out.println(State.OFF);
        for (State item : State.values()) {
            System.out.println(item);
            System.out.println(State.valueOf(item.name()));
        }
    }
}
enum State {
    ON(1), OFF(0);
    int value = 1;
    State(int value) {
        this.value = value;
    }
}

调用枚举的构造方法格式是:常量名字(xxx, xxx),如果构造方法没有参数只需要:常量名子,如:

enum State {
     ON, OFF
}

异常

Java中的异常分为checked和unchecked,checked异常必须声明在方法中或被捕获,这点我觉得比较好,必定:异常也是API的一部分,见下例:

public final class Program {
    public static void main(String[] args) {
        try {
            test();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    public static void test() throws Exception {
        throw new Exception("I am wrong!");
    }
}

所有继承Exception的异常(除了RuntimeException和它的后代之外)都是checked异常。

装箱和拆箱

Java提供了原始类型对应的引用类型,在1.5之后的版本还提供了自动装箱和自动拆箱,结合最新版本的泛型,几乎可以忽略这块。

import java.util.*;
public final class Program {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add(1);
        int item1 = (Integer) list.get(0);
        System.out.println(item1);
    }
}

注意:自动装箱和自动拆箱是Java提供的语法糖。

泛型

Java的泛型是编译器提供的语法糖,官方称之为:类型参数搽除,先看一下语法,然后总结一点规律:

泛型方法

测试代码

static <T> void puts(T msg) {
        println(msg);
    }
    static void println(Object msg) {
        System.out.println("Object:" + msg);
    }
    static void println(String msg) {
        System.out.println("String:" + msg);
    }

调用泛型方法

System.out.println("generic method test");
puts("hello");
Program.<String> puts("hello");



输出的结果是

 
generic method test
Object:hello
Object:hello

泛型类

测试代码

class TestGenericClass<T> {
    T value;
    void setValue(T value) {
        this.value = value;
    }
}

调用代码

System.out.println("generic class test");
System.out.println(t.value);



输出结果

generic class test
1

泛型接口

测试代码

interface TestInterface<T> {
    void test(T item);
}
class TestInterfaceImp1 implements TestInterface<String> {
    @Override
    public void test(String item) {
        System.out.println(item);
    }
}
class TestInterfaceImp2<T> implements TestInterface<T> {
    @Override
    public void test(T item) {
        System.out.println(item);
    }
}

调用代码

System.out.println("generic interface test");
        TestInterface<String> testInterface1 = new TestInterfaceImp1();
        testInterface1.test("hi");
        for (Method item : testInterface1.getClass().getMethods()) {
            if (item.getName() == "test") {
                System.out.println(item.getParameterTypes()[0].getName());
            }
        }
        TestInterface<String> testInterface2 = new TestInterfaceImp2<>();
        testInterface2.test("hi");
        for (Method item : testInterface2.getClass().getMethods()) {
            if (item.getName() == "test") {
                System.out.println(item.getParameterTypes()[0].getName());
            }
        }

输出结果

Java:Java快速入门

generic interface test
hi
java.lang.String
java.lang.Object
hi
java.lang.Object

类型参数约束

测试代码

class Animal {
}
class Dog extends Animal {
}
class Base<T extends Animal> {
    public void test(T item) {
        System.out.println("Base:" + item);
    }
}
class Child extends Base<Dog> {
    @Override
    public void test(Dog item) {
        System.out.println("Child:" + item);
    }
}

调用代码

System.out.println("bounded type parameters test");
        Base<Dog> base = new Child();
        base.test(new Dog());
        for (Method item : base.getClass().getMethods()) {
            if (item.getName() == "test") {
                System.out.println(item.getParameterTypes()[0].getName());
            }
        }

输出结果


bounded type parameters test
Child:Dog@533c2ac3
Dog
Animal


类型搽除过程

  1. 将泛型定义中的类型参数去掉。

     
    
    class Base {
        public void test(T item) {
            System.out.println("Base:" + item);
        }
    }
    

  2. 将T换成extends指定的约束类型,默认是Object。

class Base {
     public void test(Animal item) {
         System.out.println("Base:" + item);
     }
}

  1. 如果有非泛型类型继承或实现了泛型基类或接口,而且进行了重写,根据情况,编译器会自动生成一些方法。

    class Child extends Base {
        @Override
        public void test(Animal item) {
            this.test((Dog)item);
        }
        public void test(Dog item) {
            System.out.println("Child:" + item);
        }
    }
  2. 根据泛型参数的实际参数搽除调用代码。

    System.out.println("bounded type parameters test");
            Base base = new Child();
            base.test(new Dog());
            for (Method item : base.getClass().getMethods()) {
                if (item.getName() == "test") {
                    System.out.println(item.getParameterTypes()[0].getName());
                }
            }

 这里说的不一定正确,特别是Java泛型的约束支持&(如:可以约束实行多个接口),不过过程估计差别不大,我没有看Java语言规范,这里只是大概的猜测。

备注

这几天完成了Java基本语法的学习,关于一些高级特性在后面再慢慢总结,如:运行时进程模型、类型加载机制、反射、注解、动态代理等。

 

喜欢 (0)
[🍬谢谢你请我吃糖果🍬🍬~]
分享 (0)
关于作者:
少将,关注Web全栈开发、项目管理,持续不断的学习、努力成为一个更棒的开发,做最好的自己,让世界因你不同。
发表我的评论
取消评论

表情 贴图 加粗 删除线 居中 斜体 签到

Hi,您需要填写昵称和邮箱!

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
(3)个小伙伴在吐槽
  1. 博主,可以提供下这张图片的https://www.whatled.com/content/uploadfile/201510/7c521443957014.png思维导图吗?
    salansun2017-09-02 23:52 回复 未知操作系统 | 未知浏览器
  2. @salansun:抱歉,找不到了。。。
    admin2017-09-04 19:29 回复 未知操作系统 | 未知浏览器