JAVA两小时快速入门：基础

最新推荐文章于 2024-04-25 17:52:37 发布
最新推荐文章于 2024-04-25 17:52:37 发布
阅读量2.9k 收藏 13
点赞数 1
分类专栏： Java
  • 源代码组成方式
  • 入口方法
  • 项目框架
  • 数据类型
  • 运算符
  • 字符串
  • 数组
  • 控制结构
  • 方法
  • 类
  • 静态成员
  • 继承
  • 重载
  • 包
  • 访问级别
  • 嵌套类
  • 常量
  • interface
  • 枚举
  • 异常
  • 装箱和拆箱
  • 泛型

    建议在在线平台把下面的代码理解的同时敲一遍。

    其实java的诸多特性我觉得都是和C++一样的，除了C++有指针外，基本上都是一样的。所以在熟悉C++的情况下，我觉得理解下面的内容可以在两个小时以内搞定。然后具体做项目的时候就可以对照者现成的项目进行参考。

    源代码组成方式

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

    E:\Workspaces\MyEclipse 10\JavaStudy\src\com\happyframework\javastudy\hello\Hello.java

    package com.happyframework.javastudy.hello;

public final class Hello {
    public static void hello(){
        System.out.println("hello world!");
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    关于class有如下几点规则：

    • 文件的名字必须和class的名字一致（public级别的class名字）。
    • 文件必须只包含一个public访问基本的class（可以包含多个非public级别的class）。
    • package名字必须和目录一致。

    入口方法

    public class App {
     public static void main(String[] args) {
         com.happyframework.javastudy.hello.Hello.hello();
     }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5

    项目框架

    这里写图片描述

    数据类型

    8种原子类型

    • 整数类型：byte、short、int和long。
    • 小数类型：float和double。
    • 字符类型：char。
    • 布尔类型：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
    • 6
    • 7
    • 8
    • 9
    • 10

    运算符

    • 算术运算符：+、-、*、/ 和 %，两个整数相除，结果还是整数。
    • 赋值运算符：=、+=、-=、*=、/=、%=、&=、|=、~=、^=、<<=、>>= 、 >>>=、++ 和 –。
    • 比较运算符：==、!=、<、<=、> 和 >=。
    • 逻辑运算符：&&、|| 和 !。
    • 位运算符：&、|、~、^、<<、>> 和 >>>。

    字符串

    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
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

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

    {
            StringBuffer sb = 
                    new StringBuffer()
                    .append("段")
                    .append("光")
                    .append("伟");

            System.out.println(sb.toString());
        }
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    数组

    声明语法
    DataType[] name 或 DataType name[]。

    初始化语法
    DataType[] name = new DataType[length]。
    DataType[] name = new DataType[] { element1, element2, …elementn }。
    DataType[] name = { element1, element2, …elementn }。

    public class Program {

    /**
     * @param args
     */
    public static void main(String[] args) {
        {
            String[] strs = { "段", "光", "伟" };

            for (String item : strs) {
                System.out.print(item);
            }
        }
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

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

    控制结构

    • 条件：if-else if-else、switch-case-default和三元运算符（?:）。
    • 循环：while、do-while、for和foreach。
    • Labeled block。
    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");
        }
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

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

    方法

    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);
        }
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    类

    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 + ")";
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

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

    静态成员

    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 + ")";
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    继承

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

    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";
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32

    重载

    Java中的重写规则比较灵活，具体如下：

    • 除了 private 修饰之外的所有实例方法都可以重写，不需要显式的声明。
    • 重写的方法为了显式的表达重写这一概念，使用 @Override进行注解。
    • 重写的方法可以修改访问修饰符和返回类型，只要和父类的方法兼容（访问级别更高，返回类型更具体）。
    • 可以使用final将某个方法标记为不可重写。
    • 在构造方法中使用 super(xxx, xxx)调用父类构造方法，在常规实例方法中使用 super.method(xxx, xxx)调用父类方法。
    • 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";
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66

    包

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

    Java支持三种导入语法：

    • 导入类型：import xxx.xxx.xxxClass。
    • 导入包：import xxx.xxx.xxx.*。
    • 导入静态成员：import static xxx.xxx.*。
    import static util.Helper.*;

public class Program {

    /**
     * @param args
     */
    public static void main(String[] args) {
        puts("段光伟");
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    访问级别

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

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

    嵌套类

    Java支持如下几种嵌套类：

    • nested class，定义在类型内部的类型。
    • static nested class，使用 static 声明的 nested class，static nested class 可以访问所有外部类的静态成员。
    • 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);
            }
        }
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68

    特殊的inner class：local class：

    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();
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    除了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();
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    常量

    使用final修饰：

    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);
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

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

    interface

    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("啃骨头");
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    枚举

    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;
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

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

    enum State {
     ON, OFF
}
  
  
    • 1
    • 2
    • 3

    异常

    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!");
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    所有继承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);
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    注意：自动装箱和自动拆箱是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);
    }
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    调用泛型方法：

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

    输出的结果是：

    generic method test
Object:hello
Object:hello
  
  
    • 1
    • 2
    • 3

    泛型类

    测试类：

    class TestGenericClass<T> {
    T value;

    void setValue(T value) {
        this.value = value;
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    调用：

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

    泛型接口

    测试代码：

    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);
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    调用代码：

    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());
            }
        }
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    类型参数约束

    测试代码：

    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);
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    调用代码：

    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());
            }
        }
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    　类型擦除过程

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

    class Base {
    public void test(T item) {
        System.out.println("Base:" + item);
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5

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

    class Base {
    public void test(Animal item) {
        System.out.println("Base:" + item);
    }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5

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

     class Child extends Base {
      @Override
      public void test(Animal item) {
          this.test((Dog)item);
      }

      public void test(Dog item) {
          System.out.println("Child:" + item);
      }
 }
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    根据泛型参数的实际参数搽除调用代码。

    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());
       }
}
  
  
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

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

    参考链接：
    【1】转载地址：http://www.cnblogs.com/happyframework/p/3332243.html
    【2】入门较好的系列博客：http://www.cnblogs.com/vamei/archive/2013/03/25/2964430.html

            
     
Jinlong_Xu
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【Java基础知识 1】Java入门级概述，让阿里架构师告诉你为什么要分库分表
m0_64383736的博客
11-27 8180
1998年12月8日，第二代Java平台的企业版J2EE发布。 1999年4月27日，HotSpot虚拟机发布。 2005年6月，在Java One大会上，Sun公司发布了Java SE 6。此时，Java的各种版本已经更名，已取消其中的数字2，如J2EE更名为JavaEE，J2SE更名为JavaSE，J2ME更名为JavaME。 2009年，甲骨文公司宣布收购Sun。 2014年3月Oracle发布正式版JDK8，JDK8改进比较多，最大的改进是Lambda表达式（以及因之带来的函数式接口，很多原有类都做
Java快速入门
02-15
Java 快速入门课程是为零基础的同学设计的，旨在让他们快速掌握 Java 编程语言。课程涵盖了 Java 的基础语法、面向对象、字符串、集合、IO 流、接口、Lambda 表达式、方法引用、Stream、模块化等方面的知识点。 ...
Java基础入门
qq_58423640的博客
05-06 1万+
所谓跨平台指的是用Java语言开发的程序可以在多种操作系统上运行，常见的操作系统有Windows、Linux、MacOS系统。如果没有跨平台性，同一个应用程序，想要在多种操作系统上运行，需要针对各个操作系统单独开发应用。比如微信有Windows版本、MacOS版本、Android版本、IOS版本。
Java基础入门知识
weixin_63544745的博客
10-11 8390
java基础知识学习
Java基础教程（五千字带你快速入门！）
最新发布
小谷同学的博客
04-25 968
五千字带你快速入门Java！内容非常详细，适合新手入门，复习~期末救急包！
Java 入门 （超级详细）
qq_63519395的博客
11-21 2万+
Java是一种高级编程语言，由Sun Microsystems公司于1995年推出。Java具有跨平台性、面向对象、健壮性、安全性、可移植性等特点，被广泛应用于企业级应用开发、移动应用开发、大数据处理、云计算等领域。Java程序可以在不同的操作系统上运行，只需编译一次，就可以在任何支持Java虚拟机（JVM）的平台上运行。Java还提供了丰富的库和框架，可以加快开发过程，提高开发效率。变量是计算机程序中用于存储数据的一种数据类型。它是一个名称，代表了一个值或一个对象，可以在程序中多次使用。
java编程基础（入门级）（超级完整版）
weixin_41406651的博客
06-16 3万+
java基础编程 01基础知识 1.计算机基础 【1】进制 A.十进制转化二进制 除以2，求余数，商继续除以2，一直到0为止，从底下往上得到结果。 B.二进制转化十进制 1 | 1 | 0 | 0 23∣22∣21∣202^3 | 2^2 | 2^1 | 2^023∣22∣21∣20 8+4+0+0=128+4+0+0=128+4+0+0=12 【2】 计算机的储存方式 位（bit）：0或1 字节（byte）：8位1字节，数据储存的最小单位 1 KB=1024 Byte 1 MB=1024 KB 1 GB=
Java三小时从入门到使用
12-23
本人现在是计科专业的苦*大二仔，在大一已经学过一年的C++基础知识，漫漫寒假想打发时间，想到大二下有Java的课程，于是花了半天时间快速入门了一下Java基础语法。Java的代码风格跟C++有很多的类似之处，网上的网课...
SpringBoot两小时快速入门，极客表白浪漫红包程序.zip
03-10
速度快：加载速度相较于传统的HTML5网页更快，依托于微信强大的基础设施，能够实现近乎原生应用的流畅体验。 跨平台兼容：开发者一次开发，即可在多种终端设备上运行，免除了复杂的适配工作，大大提高了开发效率。...
SpringBoot两小时快速入门，基因芯片个人信息程序。.zip
03-10
速度快：加载速度相较于传统的HTML5网页更快，依托于微信强大的基础设施，能够实现近乎原生应用的流畅体验。 跨平台兼容：开发者一次开发，即可在多种终端设备上运行，免除了复杂的适配工作，大大提高了开发效率。...
JAVA入门1.2.3：一个老鸟的JAVA学习心得 PART1（共3个）
05-07
一一击破Java入门可能会遇到的难点和疑惑 抽丝剥茧，层层推进，让知识环环相扣，降低了学习的难度 通过大量的比喻、类比、对比和图示等多种讲解方式，学习效果好 对Java语言的每个语法都提供了一个或多个例程讲解 ...
java基础入门
mwx523037520036的博客
11-04 3172
Java基础入门知识点
java语言基础知识入门
qq_39725872的博客
06-08 1671
当前，并不是在所有的平台 下都有相应Java解释器程序，这也是Java并不能在所有的平台下都能运行的原因，它只能在已实现了Java解释器程序的平台下运行。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。因为在jdk下bin文件夹中有很多我们在开发中要使用的工具，如java.exe,javac.exe,jar.ex等,那么我们在使用时，想要在电脑的任意位置下使用这些java开发工具，那么我们就需有把这些工具所在的路径配置到系统的环境变量中，当我们使用时，系统可以帮且我们找到这些命令。
Java学习6个阶段，完整Java入门教程学习步骤来了
Python966的博客
07-11 1万+
Java是一门跨平台的面向对象编程语言，应用广泛，尤其在企业级应用开发方面有很高的竞争力。如果你想学习Java编程，那么本篇文章将为你提供一个完整的Java入门教程学习步骤，帮助你从零开始学习Java。
Java入门级基础教学（史上最详细的整合）
热门推荐
代码贩子、的博客
08-16 9万+
Java面向对象（史上最详细的整合）
Java入门必备知识
weixin_60719453的博客
09-22 1万+
目录 一、前言 二、HelloWord案例编写 三、基础语法 1.快速生成语句： 2.注释： 3.标识符 标识符： 标识符的组成： 标识符的组成规则： 4.标识符命名约定： 小驼峰命名法： 命名规则： 5.变量 变量的注意事项： 6.常量 常量的概述： 常量的种类： 7.关键字 关键字的描述： 关键字的特点： 8.java数据类型 9.类型转化 自动类型转化： 自动类型转化的原因： 强制类型转化： 一、前言 前面已经进行...
Java 快速入门
qq_55202378的博客
09-25 3107
java快速入门
JAVA之简介以及环境配置
sinat_37842336的博客
12-14 836
文章目录JavaJava 开发环境Java JDKJava JREJava 开发IDEEclipse Java Java 开发环境 Java JDK Java JDK下载地址 Java JRE 对于JDK>13的版本就不需要JRE的支持了，只需要安装JDK就可以 Java 开发IDE Eclipse Eclipse官网
Java入门（开始了解Java）
Ye_sky的博客
04-09 417
这一步主要是对程序员编写的代码（即源文件）进行错误检查，需要用到Java编译器，编译完成后会生成字节码文件，其后缀为（.class），该文件可被JVM（Java虚拟机，运行所需软件）读取。与大多数计算机高级编程语言相同，Java的开篇并不会直接开始讲那些复杂的代码，在这里我们需要从这个计算机高级语言的定义开始逐渐深入了解java，并在最后练习一些简单的代码，以此熟悉Java。如简述的字面意思，就是程序员编写程序Java程序的代码，具体来说是编写Java源文件，其文件后缀为（.java）。
快速入门：Java基础02——关键字与main方法详解
徐葳的《40小时掌握java语言之02基础语法》内部教材是一套针对Java初学者设计的系统教程，特别适合2019年后学习者，基于JDK...这40小时的学习路径旨在帮助新手快速上手Java语言，为深入学习和项目开发打下坚实的基础。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值