java快速入门
配置。 入门要开始使用Java，必须下载并安装Sun的JDK（Java开发工具包）版本。
撰写本文时，最新版本是JDK 6，可从以下位置下载
http://java.sun.com/javase/downloads/index.jsp 。我将使用JDK 5（更新8）
但在大多数情况下，它们也会提供在JDK 1.4编译器上也能使用的代码。
我还将在1.6编译器上测试一些代码。
Java开发套件这是Java程序员使用的工具。
JDK的主要组件是以下编程工具
javac-编译器，它将java源代码（.java文件）转换为Java字节码（.class文件）。
java-这将执行java类文件。 它启动Java应用程序。
appletviewer-不需要Web浏览器即可运行和调试applet。
jar-Java归档程序，它将相关的类库（和其他文件）打包到一个JAR文件中。
这是Java程序的可执行文件。
javadoc-此工具使用源代码中的注释生成文档。
jdb-调试器
JDK包含（JRE）Java运行时环境。 它由Java虚拟机和将在生产环境中提供的类库组成，其中包括对开发人员有用的其他库。
设置类路径。成功下载并安装JDK后，您需要设置类路径。
默认情况下，无需设置路径即可访问JDK标准API的软件包。
只能在命令行中或在与包含类的Jar文件相关联的清单中设置用户定义的包和库的路径（第二种方法是
在获取jar文件时会被重新访问）。
如何设置类路径取决于您使用的操作系统。
您可以在此处获取有关如何为您的操作系统版本设置类路径的信息
http://java.sun.com/j2se/1.5.0/docs/...classpath.html下面的文章是对类路径的全面讨论。
http://mindprod.com/jgloss/classpath.html当我们看到一些JDK工具正在使用时，我们还将在以后修改设置。
您将需要使用诸如TextPad，JCreator，notepad ++等的接口程序来编写代码。
重要的是选择一个您了解的工具。 还有像Netbeans（在Sun站点上可用）之类的IDE，但是，仅在您完全熟悉该语言的基本功能之后，您才想使用它们。
编译Java代码。如前所述，javac工具是用于编译Java类的工具。 您可以通过在提示符下键入javac FileName.java来调用它。 如果您正在使用诸如TextPad之类的程序，则只需单击“编译Java”按钮，然后将调用该工具。 如果代码没有任何错误，则对于上面的示例，javac会生成一个名为FileName.class的类文件。 如果代码有错误，它们将显示在命令提示符下。
不需要在文件中具有公共类定义。 在这种情况下，文件的名称应与不应公开的类和接口的名称不同。 换句话说，没有公共类的文件可以具有与文件中任何类都不匹配的名称。
这是因为每个文件最多允许一个公共类定义。
此类的名称应与文件名匹配。 如果有多个公共类定义，则编译器将接受带有文件名的类，并在定义另一个类的行给出错误。 一个空白文件可以正确编译（是有效的Java源文件）。
javac错误消息编译错误对程序员来说非常重要。 如果编译器在编译期间输出错误消息，则不会生成类文件。 编译错误包括发生错误的行号。
如果您的界面程序有行号（一个好的界面程序应该有行号，并且您应该始终启用它们），这将非常有用。 当寻求帮助时（例如在Java论坛中总是包含错误消息）。
下一部分将介绍Java基础知识并将包含Java程序。 因此，请确保您可以在计算机上编译并运行Java程序。
Java基础这些文章中的方法是尽快开始编写程序，然后在以后扩展编程的主要功能。 如果有人具有编写程序的经验，就可以轻松理解这些功能。
语言结构Java编程语言是一种高级的面向对象的语言，它是基于类的，并支持并发。 它也是强类型的，即可以区分编译时错误
（可以并且必须在编译时检测到），以及在运行时发生的运行时错误（异常）。
语言区分大小写和自由格式（语句可以驻留在行的任何位置，可以跨越行或在标记之间允许任意数量的空格）
语句以分号（;）终止。 仅包含分号的Java文件是有效的Java源文件。
为了运行Java应用程序，正在运行的类必须包含具有以下签名的main方法：
public static void main(String[] args)public static void main(String ... args) 从jdk 1.5开始，以下是Java关键字集。
{为新的，切换的，断言的，断言的，默认的，摘要，继续
包，已同步，布尔值，执行，转到，私有，此，中断，
double，实现，保护，throw，byte，else，import，public，
抛出，case，enum，instanceof，return，transient，catch，extends，
int，short，try，char，final，interface，static，void，class，
最后，长，strictfp，易失性，常量，浮点数，本机，超级，而}
const和goto被保留，即使它们当前不是
用过的。 稍后我们将介绍其他关键字。
原始类型Java具有以下八种原始类型：
布尔，字节，短，字符，整数，长，浮点和双精度。
你应该有一张他们的桌子
最小值，最大值和初始值。
文字在编译时会检查其大小。
byte b = 128; //will not compile (Maximum value of byte is 127) but
byte c = 127; //will compile现在，我要说一个字面量是原始类型（源代码表示形式）或null或String类型的值（稍后将进行检查）。
文字不是关键字。 即null，true，false等不是关键字。
统一码如果您想成为一名认真的程序员，学习一些unicode是明智的。
现在，我要说的是Unicode字符可以出现在Java代码的任何地方。 它们以\ u为前缀，长度为四个字符。 例如，“ a”由\ u0061表示。 您可以将“ a”替换为“ \ u0061”
在您的代码中，它将仍然编译。 因此，以下内容是等效的：
boolean b = true;
boole\u0061n b = true;以下九个ASCII字符是分隔符（标点符号）：
（）{} []; ，。
经营者完整的运算符集是：
=> <！ 〜？ ：
== <=> =！= && || ++-
+-* /＆| ^％<< >> >>>
+ =-= * = / =＆= | = ^ =％= << = >> = >>> =
算术运算符-*，/，％，+，-只能应用于数字类型（至少为int），但+可以应用于字符串文字。
扩展赋值运算符和++-运算符执行隐式类型转换。
byte a = 12;
a = a + 1;byte a = 12;
a++;注意
byte b = 127;
b++;
System.out.println(b);运算符&&和|| 是短路逻辑运算符。 如果第一个操作数的值足以确定整个表达式的值，则不评估右侧。
boolean s = true;
boolean t = true;
if((t = false) && (s = false) ) {
;
}
System.out.println(t);
System.out.println(s);false
true您应该尝试与其他运算符（尤其是移位运算符）一起理解它们的功能。
您还应该注意每个运算符的关联性。
例如
System.out.println( 1 + 2 + "3" ); // Prints 33
System.out.println( "1" + 2 + 3 ); // Prints 123讨论完继承后，我们将看一下instanceof运算符。
身份标识标识符是您为变量指定的名称。 Java标识符必须以字母，美元符号（$）或下划线（_）开头。 后面的字符可以是字母，$，_或数字。标识符不能具有Java关键字的名称或文字。
允许嵌入关键字或文字
Java类型。每个变量和每个表达式都具有在编译时已知的类型（强类型）。
Java中有两种广泛的类型：原始类型和引用类型。
类型：
PrimitiveType ， ReferenceTypePrimitiveType：
NumericType ，布尔值ReferenceType：类，数组，接口
NumericType：
积分类型 ， 浮点类型IntegralType：int，long，char，byte，short
FloatingPointType：浮点数，双精度
这就是我现在将要介绍的原始类型的全部内容。 接下来是Class类型。
Java类 什么是类？类定义了新的引用类型以及如何实现该引用类型。
目前查看类的最好方法是，它是用于制作对象的模板。 因此，类不同于对象。 对象就像类的实现。 您可以定义一个类，并使用同一类创建许多不同的对象。 类是在编译时创建的，而对象是在运行时在内存中创建的。 类指定对象可以执行的属性和动作。 将属性指定为字段，而将动作指定为方法。 在程序开发过程中，设计类非常重要。 如果精心设计类以及类之间的关系，您将发现解决Java真正的问题很容易。 类关系是通过继承和组合指定的。 这两个非常重要，应该掌握。
封装形式封装的简单定义是组合元素以创建新实体。 这个想法是隐藏某些信息，以使关注点分离。 代码被分组到模块中，这样模块外就没有代码了。 Java直接支持封装，因为您编写的每一行代码都必须在某个类中。 类外没有代码。 这将带来一些后果，并且在此过程中将变得显而易见。 结果是，如果代码没有类，则无法创建任何对象。
接下来，我们将发现包之外没有类。
Java包包是一种根据文件的功能，可用性和所属类别将文件组织到不同目录中的方法。 这具有易于维护，组织的优点，并且（额外）使我们能够在不同的程序包中重用相同的类名。 将包视为包含类的文件夹。 如果在文本编辑器中键入以下内容并将其另存为PackageTest.java
package test;
class PackageTest {
public static void main(String[] args) {
System.out.println("Tested");
}
} 没找到。 但是，如果您创建一个名为test的文件夹，然后将该文件放入该文件夹中，然后编译并运行该文件，则会在控制台上打印“ Tested”。 JVM需要完全限定的类名来加载该类，因此您需要使用java test.PackageTest来运行它。 或者，您可以使用classpath变量指定.class的位置。
要使用包的类，请使用import语句将它们导入代码中。 包声明在导入语句之前。 已经创建了许多软件包供您导入并在您的代码中使用。
您应该始终尝试利用Java api中的类
在这里 。 编译器会自动为您导入java.lang包。 类结构类声明以修饰符开头，修饰符可以是
公共，受保护，私有，抽象，静态，strictfp，最终。
为了让我们开始，我们将首先查看public和protected修饰符。
Java类封装在包中。 一个包中的类只能访问另一个包中的公共类。 受保护的类只能在已定义的包中访问。 如果不包括修饰符，则认为是受保护的访问。 该类放在为您自动创建的默认包中。
您应该始终将类放在包中。 这是Java类的其余结构：
修饰符类ClassName {
成员（方法，字段，嵌套类和接口）
构造函数
静态初始化器
}
这三个组件中的每个组件都是可选的。
静态关键字。如果在类内部将变量（包括方法）定义为静态，则该变量属于该类，但不属于该类的实例（对象）（创建对象时，不会为静态变量分配内存）。
因此，无需创建该类的对象即可访问静态变量。
package religion;
class Church {
static int members;
public static void main(String[] args) {
System.out.println(members); //or Church.members
}
} package religion;
class Church {
static int members;
public static void main(String[] args) {
System.out.println(Church.members);
}
} 在静态上下文中只能访问静态变量。
package religion;
class Church {
static int members;
int pastors;//pastors is not static
public static void main(String[] args) {//main is a static context(modified by keyword static)
System.out.println(Church.members);
System.out.println(Church.pastors);//! will not compile
}
} 始终在程序运行之前首先解析静态初始化程序
package religion;
class Church {
static int members;
public static void main(String[] args) {
System.out.println(Church.members);
System.out.println(Church.pastors);
}
static int pastors = 5;
} Math类包含许多可以重用的静态方法。 它位于java.lang包中，因此您无需导入任何内容即可使用它。
package tests;
class EasyMath {
public static void main(String[] args) {
System.out.println(Math.PI); //static constant
System.out.println(Math.pow(2, 6)); //static mothod
}
}到目前为止，我们还没有创建任何对象。 对象是在运行时从在编译时创建的类中创建的。 new关键字用于创建对象。
package religion;
class Church {
static int pastors;
public static void main(String[] args) {
//System.out.println(Church.pastors);
Church c = new Church();
}
}
package religion;
class Church {
int pastors;
public static void main(String[] args) {
Church c = new Church();
System.out.println(c.pastors);
}
} 到屏幕。 注意，牧师不再可以通过类名访问，而只能通过取消引用对象c来访问。
我们可以将更多不同数据类型的变量添加到字段区域，每个变量都将成为创建的任何对象的一部分
从那个班级。
方法方法具有返回类型和签名。 签名由方法名称，参数数量和参数顺序组成。 一个方法最多可以返回一个值。 同一类中不能有两个具有相同签名的方法。
因此请注意
void a (int x, double y) void a (double x, int y) 我们已经看过了类方法，它们是静态方法。 请记住，它们只能访问静态变量。
实例方法（非静态）在特定对象的上下文中执行。 它们对当前对象的实例变量进行操作，并可以使用“ this”关键字引用对象本身。
package religion;
class Church {
int pastors;
public static void main(String[] args) {
Church c = new Church();
c.setPastors(10);
c.printPastors();
}
public void setPastors(int p) { //returns nothing takes one int
pastors = p;
// or this.pastors = p;
}
public int getPastors() { //returns int takes nothing
return pastors;
}
public void printPastors() { //returns nothing takes nothing
System.out.println(pastors);
}
} 类的另一部分是构造函数。 请注意，与C ++不同，java中没有析构函数。 构造函数用于创建对象。 使用new关键字创建类的新实例时，将调用该类的构造函数。
构造函数用于初始化对象的实例变量（字段）。 它们与方法相似，但有一些重要区别。 构造函数没有返回类型（值始终是此对象）。 它们必须与所在类具有相同的名称。每个类至少具有一个构造函数。 如果您没有为类定义构造函数（就像我们在上面的示例中所做的那样），则编译器会自动创建一个默认的无参数构造函数。 默认的构造函数调用默认的父构造函数（我们将在继承的下一课中对此进行检查），并将所有实例变量初始化为默认值（数字类型为零，对象引用为null，布尔值为false）。 请注意，仅当没有构造函数时才创建默认构造函数。 如果为类定义任何构造函数，则不会自动创建默认构造函数。 所以
package religion;
class Church {
public static void main(String[] args) {
Church c = new Church();//calls default no-arg constructor automatically created by compiler
}
} package religion;
class Church {
public Church(long a) {
}
public static void main(String[] args) {
Church c = new Church();//calls default no-arg constructor automatically created by compiler
}
} 创建无参数构造函数。 您可以根据需要定义尽可能多的构造函数，只要它们具有不同的签名即可。
package religion;
class Church {
int pastors;
public Church() {// initializes pastors to 0
pastors = 0;
}
public Church(int pastors) {// initializes pastors to the given value
this.pastors = pastors;
}
public static void main(String[] args) {
Church c1 = new Church();
c1.printChurch();
Church c2 = new Church(10);
c2.printChurch();
}
public void printChurch() {
System.out.println("Church with :" + getPastors() + " Pastors");
}
public int getPastors() {
return pastors;
}
}public Church(int pastors) {// initializes pastors to the given value
this.pastors = pastors;
} 您应该使用构造函数仅初始化变量。
构造函数可以在相同的类（或不同的类）中调用另一个构造函数。有关继承的信息，将在下一个类中进行检查。
为此，请使用“ this”关键字。 这必须是构造函数的第一行。
package religion;
class Church {
int pastors;
int members;
public Church() {
pastors = 0;
members = 0;
}
public Church(int pastors) {
this(); // calls the default constructor so members is also initialized to 0.
this.pastors = pastors;
}
public Church(int pastors, int members) {
this(pastors); // calls the one-arg constructor so pastors has been initialized.
this.members = members;
}
} 使用修饰符表示一个变量最多被分配一个值。 编译器不允许您两次将值赋值给最终变量。
package religion;
class Church {
final int pastors;
public Church() {
pastors = 0;
}
public Church(int pastors) {
this.pastors = pastors;
this.pastors = 2; //! will not compile
}
} 如果在不初始化最终变量的情况下将其声明为类的成员变量，则必须在该类的每个构造函数中初始化该最终变量，否则编译器将给出错误信息。
package religion;
class Church {
final int pastors;
public Church(int pastors) {
this.pastors = pastors;
}
public Church() { //! will not compile (variable pastors might not have been initialized)
}
}翻译自: https://bytes.com/topic/java/insights/740375-quick-introduction-java-concepts-1-a
java快速入门
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
