JAVA两小时快速入门：基础

最新推荐文章于 2023-12-21 17:22:07 发布
最新推荐文章于 2023-12-21 17:22:07 发布
阅读量1.6k 收藏 9
点赞数 3
分类专栏： Leetcode 文章标签： java 快速入门 基础篇 入门 基础

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

其实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!");
    }
}

关于class有如下几点规则：

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

入口方法

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

项目框架

这里写图片描述

数据类型

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);
    }
}

运算符

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

字符串

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。

{
            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 }。

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]。

控制结构

  • 条件：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");
        }
    }
}

最近觉得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);
        }
    }
}

类

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中类似静态构造方法的结构，称之为：静态初始化代码块，与之对应的是实例初始化代码块，见下例：

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，见下例：

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中的重写规则比较灵活，具体如下：

  • 除了 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";
    }
}

包

包的名字和项目路径下的目录路径相对应，比如：项目路径为：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("段光伟");
    }
}

访问级别

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);
            }
        }
    }
}

特殊的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();
    }
}

除了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();
}

常量

使用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);
    }
}

有一点需要注意的是：只有一种情况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("啃骨头");
    }
}

枚举

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);

泛型接口

测试代码：

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());
            }
        }

类型参数约束

测试代码：

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());
            }
        }

　类型擦除过程

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

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

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

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

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

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

      public void test(Dog item) {
          System.out.println("Child:" + item);
      }
 }

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

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语言规范，这里只是大概的猜测。

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

Snail_Walker
关注
专栏目录
Java入门（一）
Kaiii的博客
01-05 3785
Java入门（一）Java概述Java中重要的特性Java的运行机制初识Java和main方法最简单的Java程序mian方法的示例Java中的数据类型 Java概述 Java是一种优秀的程序设计语言，它具有令人赏心悦目的语法和易于理解的语义。不仅如此，Java还是一个有一系列计算机软件和规范形成的技术体系，这个技术体系提供了完整的用于软件开发和跨平台部署的支持环境，并广泛应用于嵌入式系统、移动终端、企业服务器、大型机等各种场合。 Java中重要的特性 1.简单性 Java语法是C++语法的一个“纯净版本”
Java快速入门
02-15
Java 快速入门课程是为零基础的同学设计的，旨在让他们快速掌握 Java 编程语言。课程涵盖了 Java 的基础语法、面向对象、字符串、集合、IO 流、接口、Lambda 表达式、方法引用、Stream、模块化等方面的知识点。 ...
Java：Java快速入门
weixin_33728268的博客
09-25 565
你好，世界！ 源代码组织方式 Java程序由package+class组成，package对应目录的相对路径，class对应文件，如 E:\Workspaces\MyEclipse 10\JavaStudy\src\com\happyframework\javastudy\hello\Hello.java 1 package com.happyframework.javastudy.h...
真正的Java学习从入门到精通
yuanhkjun的专栏
03-10 942
 一、 工具篇JDK (Java Development Kit)JDK是整个 Java的核心，包括了Java运行环境（Java Runtime Envirnment），一堆Java工具和Java基础的类库(rt.jar)。不论什么Java应用服务器实质都是内置了某个版本的JDK。因此掌握 JDK是学好Java的第一步。最主流的JDK是Sun公司发布的JDK，除了Sun之外，还有很多公司和组织都开
Java入门
qq_44799830的博客
12-26 1126
一、多态 1.Abstract_Music.java（抽象） enum Note1{ Low,Middle,High } abstract class Instrument1{ abstract void play(Note n); abstract void adjust(); } class Wind1 extends Instrument1{ void play(Note n){System.out.println("Wind1 play()");}
java入门
m0_58660225的博客
12-21 1132
1.静态数据字符串想要与动态的变量名进行拼接，需要使用+号2.char字符型即可以保存单个字符，需要用' '包裹，也可以保存数字，只不过数字会去查ASCII码表3.从控制台接受用户输入的数据：int a = new Scanner(System.in).nestInt();4.变量进行值交换，首先需要一个第三方变量协助交换，代码的格式：斜相对，首尾相连1.定义的时候并赋值： 变量的类型 变量名=变量值；比如： int a=19;2.先定义，后面再赋值：int a;a=99;
SpringBoot两小时快速入门，极客表白浪漫红包程序.zip
最新发布
03-10
速度快：加载速度相较于传统的HTML5网页更快，依托于微信强大的基础设施，能够实现近乎原生应用的流畅体验。 跨平台兼容：开发者一次开发，即可在多种终端设备上运行，免除了复杂的适配工作，大大提高了开发效率。...
SpringBoot两小时快速入门，基因芯片个人信息程序。.zip
03-10
速度快：加载速度相较于传统的HTML5网页更快，依托于微信强大的基础设施，能够实现近乎原生应用的流畅体验。 跨平台兼容：开发者一次开发，即可在多种终端设备上运行，免除了复杂的适配工作，大大提高了开发效率。...
徐葳《40小时掌握java语言之01编程入门》内部教材
03-26
在《40小时掌握java语言之01编程入门》这本教材中，我们首先接触到的是计算机语言的基础知识。软件定义为一系列按照特定顺序组织的计算机数据和指令的集合，它能够执行特定的任务或解决问题。编程则是编写软件的过程...
JAVA入门
weixin_46359556的博客
06-03 50
JAVA 入门 配置环境 下载jdk8 安装指定目录 配置环境变量 增加JAVA_HOME变量，路径为安装jdk目录 点击环境变量中的path，增加两个变量，分别为%JAVA_HOME%/bin和%JAVA_HOME/jre/bin%,添加后保存即可 验证是否成功配置环境 打开cmd 输入java -version，如显示版本，则配置成功 下载IDEA 新建项目 选择文件夹 创建项目好之后，鼠标右键src，new一个java class 编写代码 点击运行便可运行代码 Hello world 快捷指
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值