Java编程基础

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程 。
Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等 。上线时间 1995年

目录

1、Java程序的结构

vpublic class Main {//Main类
    /*
     类名要求：首字母应该大写，英语字母开头
     */
    public static void main(String[] args) {
        //main方法，java程序运行的入口（起始点）
        System.out.println("Hello, world!");
    }
//public：访问修饰符  static：关键字（静态方法）  void：返回类型（表示没有任何返回值。）   main：方法名   String[] args：String类数组
//    Java入口方法的几个要求：
//    1.方法必须是 static：关键字（静态方法）
//    2.返回值必须是void
//    3.方法名是main
//    4.括号内的参数必须是String[] args数组。
}

运行效果：

2、Java标识符、关键字、修饰符、程序注释

Java标识符是用来给类、对象、方法、变量、接口和自定义数据类型命名的。

• 所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
• 首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
• 关键字不能用作标识符
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、_value、__1_value
• 非法标识符举例：123abc、-salary（本段来自菜鸟教程）

Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数，不可以将关键字作为标识符使用。。

• 48个关键字：abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while。
• 2个保留字（现在没用以后可能用到作为关键字）：goto、const。
• 3个特殊直接量：true、false、null。
  详情解释
  • 推荐链接1
  • 链接2

Java修饰符是用来修饰类中方法和属性。主要有两类修饰符：

• 访问控制修饰符 : public ,default, protected, private
• 非访问控制修饰符 : final, abstract, static, synchronized
  详情解释
• 链接1
• 链接2

Java程序注释

注释信息只保存在Java源文件当中,Java源文件编译生成的字节码class文件是没有这些注释信息的。
注：文档注释例外，也就是说文档注释在class文件有 。

1.单行注释

2.多行注释

3.文档注释（说明注释、Javadoc注释）注：Java特有

Java文档注释–Javadoc的用法链接

3、Java变量和常量

变量的定义：在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在一些内存单元中，每个内存单元都用一个标识符来标识。这些内存单元被称为变量，定义的标识符就是变量名，内存单元中存储的数据就是变量的值。

变量的命名规则：

• 变量名必须是一个有效的标识符
• 不可以使用Java关键字
• 变量名不能重复
• 选择有意义的单词作为变量名

变量的有效范围：成员变量（全局变量）、局部变量

有效范围是程序代码能够访问该变量的区域，若超出该区域，则在编译时会出现错误。

在类体中定义的变量为全局变量，全局变量在整个类中都有效。全局变量又分为两种：静态变量和实例变量

如果在成员变量前加static,实例变量就成为静态变量；
静态变量的有效范围可以跨类、甚至可以到达整个应用程序之内。
对于静态变量，除了能在他的类体内存取，还能以“类名。静态变量”的方式在其他类内使用。

局部变量(在类的方法中声明变量，包括方法的参数都属于局部变量)：只在当前定义的方法内有效,不能用于类的其他方法中。局部变量的生命周期取决于方法，当方法被调用时，Java虚拟机为方法中的局部变量分配内存空间，当该方法调用结束后，则会释放方法中局部变量占用的内存空间，局部变量也将被销毁。 局部变量可与成员变量的名字相同，此时成员变量将被隐藏，即这个成员变量在此方法中暂时失效。

常量 的定义：在程序运行过程一不被改变的值成为常量（constant）。通常也被称为”final变量“、常量在整个程序中只被赋值一次、在为所有对象共享值时、常量还是非常有用的。

• 声明常量的标准语法为：final 数据类型 变量名=值 （final boolean A = true;）
• 常量名通常使用大写字母，但这不是必须。很多Java程序员使用大写字母表示常量，是为了清楚的表明正在使用常量。
• 当定义的final变量为成员变量时，必须在定义时就设定它的初始值，否则将会提示编译错误。
  

public class Main {
    static final double HEIGHT = 180;// 常量/静态变量
    static int age = 20;// 静态变量(Static variable)
    final double PI = 3.14;// 声明int类型常量，当定义的final变量为成员变量时，必须在定义时就设定它的初始值，否则将会提示编译错误。
    String name;// 成员变量(Member variables)，也称为全局变量,对象的属性;成员变量也分为静态变量和实例变量
    int weight = 45;// 实例变量(Instance variable)

    public static void main(String[] args) {
        final String tag;// 常量(constant)，当定义的final变量为成员变量时,可以赋初始值，也可以不赋值
        String sex = "女";// 局部变量(Local variable)
        tag = "A";
        int age = 21;
//		tag = "B";// 错误的代码。常量在整个程序中只能被赋值一次。
        System.out.println(tag + "\t" + sex);
        System.out.println("年龄为：" + age);
    }
}

链接1
链接2

4、Java 基本数据类型

Java基本类型共有八种，基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。实际上，JAVA中还存在另外一种基本类型void，它也有对应的包装类 java.lang.Void，不过我们无法直接对它们进行操作。

链接1
链接2
链接3

5、Java 运算符

算术运算符 + 、 - 、* 、 / 、％ 、 ++ 、 –

-

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("b / a = " + (b / a));
        System.out.println("b % a = " + (b % a));
        System.out.println("c % a = " + (c % a));
        System.out.println("a++ = " + (a++));
        System.out.println("a-- = " + (a--));
        // 查看  d++ 与 ++d 的不同
        System.out.println("d++ = " + (d++));
        System.out.println("++d = " + (++d));
    }
}

关系运算符 == 、 != 、 > 、 < 、 >= 、 <=

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("a == b = " + (a == b) );
        System.out.println("a != b = " + (a != b) );
        System.out.println("a > b = " + (a > b) );
        System.out.println("a < b = " + (a < b) );
        System.out.println("b >= a = " + (b >= a) );
        System.out.println("b <= a = " + (b <= a) );
    }
}

位运算符 ＆ 、 | 、 ^ 、 〜 、 << 、 >> 、 >>>

public class Main {
    public static void main(String[] args) {
        int a = 60; /* 60 = 0011 1100 */
        int b = 13; /* 13 = 0000 1101 */
        int c = 0;
        c = a & b;       /* 12 = 0000 1100 */
        System.out.println("a & b = " + c );
        c = a | b;       /* 61 = 0011 1101 */
        System.out.println("a | b = " + c );
        c = a ^ b;       /* 49 = 0011 0001 */
        System.out.println("a ^ b = " + c );
        c = ~a;          /*-61 = 1100 0011 */
        System.out.println("~a = " + c );
        c = a << 2;     /* 240 = 1111 0000 */
        System.out.println("a << 2 = " + c );
        c = a >> 2;     /* 15 = 1111 */
        System.out.println("a >> 2  = " + c );
        c = a >>> 2;     /* 15 = 0000 1111 */
        System.out.println("a >>> 2 = " + c );
    }
}

逻辑运算符 && 、 | | 、 ！

public class Main {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println("a && b = " + (a && b));
        System.out.println("a || b = " + (a || b));
        System.out.println("!(a && b) = " + !(a && b));
    }
}

赋值运算符 = 、 + = 、- = 、* = 、/ = 、（％）= 、<< = 、>> = 、＆= 、^ = 、| =

public class Main {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c);
        c += a;
        System.out.println("c += a  = " + c);
        c -= a;
        System.out.println("c -= a = " + c);
        c *= a;
        System.out.println("c *= a = " + c);
        a = 10;
        c = 15;
        c /= a;
        System.out.println("c /= a = " + c);
        a = 10;
        c = 15;
        c %= a;
        System.out.println("c %= a  = " + c);
        c <<= 2;
        System.out.println("c <<= 2 = " + c);
        c >>= 2;
        System.out.println("c >>= 2 = " + c);
        c >>= 2;
        System.out.println("c >>= 2 = " + c);
        c &= a;
        System.out.println("c &= a  = " + c);
        c ^= a;
        System.out.println("c ^= a   = " + c);
        c |= a;
        System.out.println("c |= a   = " + c);
    }
}

其他运算符 条件运算符（?:）、 instanceof 运算符

public class Main {
    public static void main(String[] args) {
//        条件运算符（?:）
        int a, b;
        a = 10;
        // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
        b = (a == 1) ? 20 : 30;
        System.out.println("Value of b is : " + b);
        // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
        b = (a == 10) ? 20 : 30;
        System.out.println("Value of b is : " + b);
//   instanceof 运算符  该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
        String name = "James";
        boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真
        System.out.println(result);
    }
}

推荐链接1
链接2
链接3

6、Java字符和字符串

装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。
字符和字符串是两个不同的类型。

字符:char是基本数据类型，它是character的缩写。一个char保存一个Unicode字符：

常用的几种函数：

isDigit()——是否为数字

isLetter()——是否为字母

isLetterOrDigiht()——是否为字母或数字

isLowerCase()——判断是否为小写

isUpperCase()——判断是否为大写

toLowercase()——返回小写

toUpperCase()——返回大写

public class Main {
    public static void main(String[] args) {
        // 定义字符
        char c1 = 'a';
        char c2 = '1';
        char c3 = '中';
// 自动装箱
        Character c = c1;
// 自动拆箱
        c1 = c;
//判断是否为字母
        System.out.println(Character.isLetter('a'));;
//判断是否为数字
        System.out.println( Character.isDigit('a'));;
//判断是否空白
        System.out.println(Character.isWhitespace(' '));
//判断是否大写
        System.out.println(Character.isUpperCase('a'));
//判断是否小写
        System.out.println(Character.isLowerCase('a'));
//转换为大写
        System.out.println(Character.toUpperCase('a'));
//转换为小写
        System.out.println(Character.toLowerCase('A'));
//转换为字符串
        String str = Character.toString('a');
        System.out.println(str);
    }
}

转义字符:“abc"xyz”，编译器就无法判断中间的引号究竟是字符串的一部分还是表示字符串结束。这个时候，我们需要借助转义字符。

public class Main {
    public static void main(String[] args) {
        // 使用 t 制表符对齐输出内容
        System.out.println("abctdef");
        System.out.println("atdef");
// 一个 t 制表符显示长度是8
        System.out.println("12345678def");
// 换行符 n
        System.out.println("abcndef");
// 单引号 '
        System.out.println("abc'def");
// 单引号 "
//        System.out.println("abc"def");错误格式不能运行
// 反斜杠 \
         System.out.println("abc\"xyz");// 包含7个字符: a, b, c, ", x, y, z
        String sa = "abc\\xyz"; // 包含7个字符: a, b, c, \, x, y, z
        System.out.println(sa);
    }
}

常见的转义字符包括：

•  \" 表示字符"
  

•  \' 表示字符'
  

• \\ 表示字符\
  

• \n 表示换行符
  

• \r 表示回车符
  

• \t 表示Tab
  

• \u#### 表示一个Unicode编码的字符
  

• 链接

字符串：字符的组合，和char类型不同，字符串类型String是一种引用类型：

1.String 本身是一个类，创建字符串后得到的是一个对象
2.String 使用final修饰，不能被继承
3.String 创建后不可改变，如增减长度、插入删除字符、修改字符等
4.一个字符串可以存储0个到任意个字符
5.如果用+连接字符串和其他数据类型，会将其他数据类型先自动转型为字符串，再连接
6.如果我们要表示多行字符串，使用+号连接会非常不方便，从Java 13开始，字符串可以用"""…"""表示多行字符串（Text Blocks）了

public class Main {
    public static void main(String[] args) {
        String s = """
                   SELECT * FROM
                     users
                   WHERE id > 100
                   ORDER BY name DESC
                   """;
        System.out.println(s);
    }
}

7.字符串不可变

public class Main {
    public static void main(String[] args) {
        String s = "hello";
        System.out.println(s); // 显示 hello
        s = "world";
        System.out.println(s); // 显示 world

        String sq = "hello";
        String t = sq;
        sq = "world";
        System.out.println(t); // hello
        System.out.println(sq);// world
    }
}

7.引用类型的变量可以指向一个空值null，它表示不存在，即该变量不指向任何对象。例如：
注意要区分空值null和空字符串""，空字符串是一个有效的字符串对象，它不等于null。

public class Main {
    public static void main(String[] args) {
        String s1 = null; // s1是null
        String s2; // 没有赋初值值，s2也是null
        String s3 = s1; // s3也是null
        String s4 = ""; // s4指向空字符串，不是null
    }
}

链接1
链接2

备注：换行符说明

换行符（newline）：另起一行；程序表示为：‘n’
回车符（return）：回到一行的开头；程序表示为：‘r’
在IDE里敲一个回车，实际上是回车换行符。
不同的操作系统，换行符不同。java程序中可以使用%n兼容各个平台的换行表现。

• 在DOS和Windows中，每行结尾是 “rn”；
• Linux系统里，每行结尾只有 “n”；
• Mac系统里，每行结尾是只有 “r”。