本文整合了 Java 开发的基础知识，涵盖了基础语法、数据类型、变量与修饰符、运算符以及流程控制等核心内容。
1. 简介
java简介
Java分为三个体系：
JavaSE(J2SE)(Java2 Platform Standard Edition，java平台标准版)
JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)
开发环境配置(windows下)
下载后安装，配置系统环境变量
此电脑 > 右键属性 > 高级 > 环境变量1
2
3
4
5
6
7
8变量名：JAVA_HOME
变量值：C:\Program Files (x86)\Java\jdk1.8.0_91 // 要根据自己的实际路径配置
变量名：CLASSPATH
变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar; //记得前面有个"."
变量名：Path
变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
windows10 变量值已有的上面点开，然后新建加到下方，以免破坏原有的环境变量
重启后生效
测试JDK是否安装成功
“开始”->”运行”，键入”cmd”；
键入命令: java -version、java、javac 几个命令
2. java基础语法
hello world
HelloWorld.java (源文件名必须和类名相同)1
2
3
4
5
6
7
8public class HelloWorld {
/* 第一个Java程序.
* 它将打印字符串 Hello World
*/
public static void main(String []args) { // 主方法入口：所有的Java 程序由public static void main(String args[])方法开始执行
System.out.println("Hello World"); // 打印 Hello World
}
}
（cmd在java文件的同一路径下）
- 编译
javac -encoding utf-8 HelloWorld.java(含中文最好使用 -encoding utf-8编译，以免出现错误) - 运行
java HelloWorld打印HelloWorld
类和对象
1 | public class Puppy{ // Puppy 类 一个源文件中只能有一个public类 |
import
Employee.java1
2
3
4
5
6
7
8
9
10
11import java.io.*; //下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
public class Employee{
//salary是静态的私有变量
private static double salary;
// DEPARTMENT是一个常量
public static final String DEPARTMENT = "Development ";
public static void main(String args[]){
salary = 1000;
System.out.println(DEPARTMENT+"average salary:"+salary);
}
}
EmployeeTest.java1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import java.io.*;
public class EmployeeTest{
public static void main(String args[]){
/* 使用构造器创建两个对象 */
Employee empOne = new Employee("James Smith");
Employee empTwo = new Employee("Mary Anne");
// 调用这两个对象的成员方法
empOne.empAge(26);
empOne.empDesignation("Senior Software Engineer");
empOne.empSalary(1000);
empOne.printEmployee();
empTwo.empAge(21);
empTwo.empDesignation("Software Engineer");
empTwo.empSalary(500);
empTwo.printEmployee();
}
}
编译后，执行EmployeeTest就可以得到结果
3. 基本数据类型
基本数据类型
两大数据类型：
- 内置数据类型
- 引用数据类型
内置数据类型
1 | public class PrimitiveTypeTest { |
引用数据类型
- 引用类型变量由类的构造函数创建，可以使用它们访问所引用的对象。这些变量在声明时被指定为一个特定的类型，比如Employee、Pubby等。变量一旦声明后，类型就不能被改变了。
- 对象、数组都是引用数据类型。
- 所有引用类型的默认值都是null。
- 一个引用变量可以用来引用与任何与之兼容的类型。
- 例子：Animal animal = new Animal(“giraffe”）
常量
1 | final double PI = 3.1415927; //常量指不能改变的量,用final标志,通常用大写标识 |
1 | int decimal = 100; // 十进值 |
字符串
双引号
1 | "Hello World" |
1 | char a = '\u0001'; // 变量a 的值为 '\u0001' |
4. 变量类型
变量类型
在Java语言中
- 局部变量
- 实例变量
- 类变量
所有的变量在使用前必须声明。声明变量的基本格式如下：
type identifier [ = value][, identifier [= value] ...] ;
1 | int a, b, c; // 声明三个int型整数：a、b、c。 |
局部变量
1 | public class Test{ |
实例变量
1 | import java.io.*; |
类变量
1 | import java.io.*; |
5. 修饰符
Java修饰符
主要分为以下两类：
- 访问修饰符
- 非访问修饰符
修饰符用来定义类、方法或者变量，通常放在语句的最前端
1 | public class className { |
访问控制修饰符
默认访问修饰符-不使用任何关键字
使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为public。1
2
3
4String version = "1.5.1";
boolean processOrder() {
return true;
}
私有访问修饰符-private
私有访问修饰符是最严格的访问级别，所以被声明为private的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为private。
声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问。
Private访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。1
2
3
4
5
6
7
8
9public class Logger {
private String format;
public String getFormat() {
return this.format;
}
public void setFormat(String format) {
this.format = format;
}
}
公有访问修饰符-public
被声明为public的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的public类分布在不同的包中，则需要导入相应public类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。1
2
3public static void main(String[] arguments) {
// ...
}
受保护的访问修饰符-protected
被声明为protected的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。
Protected访问修饰符不能修饰类和接口，方法和成员变量能够声明为protected，但是接口的成员变量和成员方法不能声明为protected。
子类能访问Protected修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。
下面的父类使用了protected访问修饰符，子类重载了父类的openSpeaker()方法
1 | class AudioPlayer { |
如果把openSpeaker()方法声明为private，那么除了AudioPlayer之外的类将不能访问该方法。如果把openSpeaker()声明为public，那么所有的类都能够访问该方法。如果我们只想让该方法对其所在类的子类可见，则将该方法声明为protected。
访问控制和继承
请注意以下方法继承的规则：
- 父类中声明为public的方法在子类中也必须为public。
- 父类中声明为protected的方法在子类中要么声明为protected，要么声明为public。不能声明为private。
- 父类中声明为private的方法，不能够被继承。
非访问修饰符
static : 用来创建类方法和类变量。
final : 用来修饰类、方法和变量，final修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract : 用来创建抽象类和抽象方法。
synchronized和volatile : 主要用于线程的编程。
static修饰符
- 静态变量 ： 也被称为类变量。用来声明独立于对象的静态变量,局部变量不能被声明为static变量
- 静态方法 ： 来声明独立于对象的静态方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22public class InstanceCounter {
private static int numInstances = 0;
protected static int getCount() {
return numInstances;
}
private static void addInstance() {
numInstances++;
}
InstanceCounter() {
InstanceCounter.addInstance();
}
public static void main(String[] arguments) {
System.out.println("Starting with " + InstanceCounter.getCount() + " instances");
for (int i = 0; i < 500; ++i){
new InstanceCounter();
}
System.out.println("Created " + InstanceCounter.getCount() + " instances");
}
}
final修饰符
final变量:1
2
3
4
5
6
7
8
9
10public class Test{
final int value = 10;
// 下面是声明常量的实例
public static final int BOXWIDTH = 6;
static final String TITLE = "Manager";
public void changeValue(){
value = 12; //将输出一个错误
}
}
final方法:
类中的Final方法可以被子类继承，但是不能被子类修改。
声明final方法的主要目的是防止该方法的内容被修改1
2
3
4
5public class Test{
public final void changeName(){
// 方法体
}
}
final类： 不能被继承1
2
3public final class Test {
// 类体
}
6. 运算符
Java 运算符
主要分为一下几种
- 算术运算符
- 关系运算符
- 位运算符
- 逻辑运算符
- 赋值运算符
- 其他运算符
算术运算符
ArithmeticOperator.java1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20public class ArithmeticOperator {
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++) ); // 当前语句后 +1
System.out.println("++d = " + (++d) ); // 当前语句前 +1
}
}
关系运算符
RelationalOperator.java1
2
3
4
5
6
7
8
9
10
11
12
13public class RelationalOperator {
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) );
}
}
逻辑运算符
LogicalOperators.java1
2
3
4
5
6
7
8
9public class LogicalOperators {
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));
}
}
赋值运算符
AssignmentOperator.java1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18public class AssignmentOperator {
public static void main(String args[]) {
int a = 10;
int b = 20;
int c;
c = a + b;
System.out.println("c = a + b is " + (a + b));
System.out.println("c += a is " + (c+=a) );
System.out.println("c -= a is " + (c -=a));
System.out.println("c *= a is " + (c *= a));
a = 10;
c = 15;
System.out.println("c /= a is " + (c/=a) );
a = 10;
c = 15;
System.out.println("c %= a is " + (c %= a));
}
}
条件运算符
ConditionalOperator.java1
2
3
4
5
6
7
8
9
10public class ConditionalOperator {
public static void main(String args[]){
int a , b;
a = 10;
b = (a == 1) ? 20: 30; // 不成立
System.out.println( "Value of b is : " + b ); // 30
b = (a == 10) ? 20: 30; // 成立
System.out.println( "Value of b is : " + b ); // 20
}
}
instanceOf 运算符
Car.java1
2
3
4
5
6
7
8
9class Vehicle {}
public class Car extends Vehicle { // Car 继承了Vehicle所有属性和方法
public static void main(String args[]){
Vehicle a = new Car();
boolean result = a instanceof Car; // 被比较的对象兼容于右侧类型,该运算符仍然返回true
System.out.println( result); // true
}
}
7. 分支结构
title: java分支结构
date: 2019-9-18 11:51:16
tags:
categories: java
if else
IfElse.java1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19public class Test {
public static void main(String args[]){
int x = 30;
if( x == 10 ){
System.out.print("Value of X is 10");
}
else if( x == 20 ){
System.out.print("Value of X is 20");
}
else if( x == 30 ){
System.out.print("Value of X is 30");
}
else{
System.out.print("这是 else 语句");
}
}
}
嵌套的if…else语句
1 | public class Test { |
switch语句
1 | public class Test { |