Java学习

基本语法

编写Java程序时，应注意以下几点：

• 大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
• 类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
• 方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
• 源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
• 主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。

编译运行： javac 文件名
 java  类名

Java 教程

Java 教程Java 简介Java 开发环境配置Java 基础语法Java 对象和类Java 基本数据类型Java 变量类型Java 修饰符Java 运算符Java 循环结构Java 分支结构Java Number & Math 类Java Character 类Java String 类Java StringBufferJava 数组Java 日期时间Java 正则表达式Java 方法Java Stream、File、IOJava Scanner 类Java 异常处理

Java 面向对象

Java 继承Java Override/OverloadJava 多态Java 抽象类Java 封装Java 接口Java 包(package)

Java 高级教程

Java 数据结构Java 集合框架Java 泛型Java 序列化Java 网络编程Java 发送邮件Java 多线程编程Java Applet 基础Java 文档注释Java 实例Java 8 新特性Java MySQL 连接

 Java 基础语法

Java 基本数据类型 

Java 对象和类

Java作为一种面向对象语言。支持以下基本概念：

• 多态
• 继承
• 封装
• 抽象
• 类
• 对象
• 实例
• 方法
• 重载

本节我们重点研究对象和类的概念。

• 对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
• 类：类是一个模板，它描述一类对象的行为和状态。

下图中男孩女孩为类，而具体的每个人为该类的对象：

---

Java中的对象

 

现在让我们深入了解什么是对象。看看周围真实的世界，会发现身边有很多对象，车，狗，人等等。所有这些对象都有自己的状态和行为。

拿一条狗来举例，它的状态有：名字、品种、颜色，行为有：叫、摇尾巴和跑。

对比现实对象和软件对象，它们之间十分相似。

软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。

在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成。

Java中的类

类可以看成是创建Java对象的模板。

通过下面一个简单的类来理解下Java中类的定义：

public class Dog{ String breed; int age; String color; void barking(){ } void hungry(){ } void sleeping(){ } }

一个类可以包含以下类型变量：

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。

---

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

下面是一个构造方法示例：

public class Puppy{ public Puppy(){ } public Puppy(String name){ // 这个构造器仅有一个参数：name } }

---

创建对象

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化：使用关键字new来创建一个对象。
• 初始化：使用new创建对象时，会调用构造方法初始化对象。

下面是一个创建对象的例子：

public class Puppy{ public Puppy(String name){ //这个构造器仅有一个参数：name System.out.println("小狗的名字是 : " + name ); } public static void main(String []args){ // 下面的语句将创建一个Puppy对象 Puppy myPuppy = new Puppy( "tommy" ); } }

编译并运行上面的程序，会打印出下面的结果：

小狗的名字是 : tommy

源文件声明规则

在本节的最后部分，我们将学习源文件的声明规则。当在一个源文件中定义多个类，并且还有import语句和package语句时，要特别注意这些规则。

• 一个源文件中只能有一个public类
• 一个源文件可以有多个非public类
• 源文件的名称应该和public类的类名保持一致。例如：源文件中public类的类名是Employee，那么源文件应该命名为Employee.java。
• 如果一个类定义在某个包中，那么package语句应该在源文件的首行。
• 如果源文件包含import语句，那么应该放在package语句和类定义之间。如果没有package语句，那么import语句应该在源文件中最前面。
• import语句和package语句对源文件中定义的所有类都有效。在同一源文件中，不能给不同的类不同的包声明。

类有若干种访问级别，并且类也分不同的类型：抽象类和final类等。这些将在访问控制章节介绍。

除了上面提到的几种类型，Java还有一些特殊的类，如：内部类、匿名类。

---

Java包

包主要用来对类和接口进行分类。当开发Java程序时，可能编写成百上千的类，因此很有必要对类和接口进行分类。

Import语句

在Java中，如果给出一个完整的限定名，包括包名、类名，那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

例如，下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类

import java.io.*;

1. java因强制要求类名（唯一的public类）和文件名统一，因此在引用其它类时无需显式声明。在编译时，编译器会根据类名去寻找同名文件。

   stinkaroo

      stinkaroo

     190***276@qq.com

   3个月前 (05-08)

2.    LadyLeane

     q-b***sn.com

   package 的作用就是 c++ 的 namespace 的作用，防止名字相同的类产生冲突。Java 编译器在编译时，直接根据 package 指定的信息直接将生成的 class 文件生成到对应目录下。如 package aaa.bbb.ccc 编译器就将该 .java 文件下的各个类生成到 ./aaa/bbb/ccc/ 这个目录。

   import 是为了简化使用 package 之后的实例化的代码。假设 ./aaa/bbb/ccc/ 下的 A 类，假如没有 import，实例化A类为：new aaa.bbb.ccc.A()，使用 import aaa.bbb.ccc.A 后，就可以直接使用 new A() 了，也就是编译器匹配并扩展了 aaa.bbb.ccc. 这串字符串。

Java关键字

下面列出了Java保留字。这些保留字不能用于常量、变量、和任何标识符的名称。

 

关键字	描述
abstract	抽象方法，抽象类的修饰符
assert	断言条件是否满足
boolean	布尔数据类型
break	跳出循环或者label代码段
byte	8-bit 有符号数据类型
case	switch语句的一个条件
catch	和try搭配捕捉异常信息
char	16-bit Unicode字符数据类型
class	定义类
const	未使用
continue	不执行循环体剩余部分
default	switch语句中的默认分支
do	循环语句，循环体至少会执行一次
double	64-bit双精度浮点数
else	if条件不成立时执行的分支
enum	枚举类型
extends	表示一个类是另一个类的子类
final	表示一个值在初始化之后就不能再改变了 表示方法不能被重写，或者一个类不能有子类
finally	为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。
float	32-bit单精度浮点数
for	for循环语句
goto	未使用
if	条件语句
implements	表示一个类实现了接口
import	导入类
instanceof	测试一个对象是否是某个类的实例
int	32位整型数
interface	接口，一种抽象的类型，仅有方法和常量的定义
long	64位整型数
native	表示方法用非java代码实现
new	分配新的类实例
package	一系列相关类组成一个包
private	表示私有字段，或者方法等，只能从类内部访问
protected	表示字段只能通过类或者其子类访问 子类或者在同一个包内的其他类
public	表示共有属性或者方法
return	方法返回值
short	16位数字
static	表示在类级别定义，所有实例共享的
strictfp	浮点数比较使用严格的规则
super	表示基类
switch	选择语句
synchronized	表示同一时间只能由一个线程访问的代码块
this	表示调用当前实例 或者调用另一个构造函数
throw	抛出异常
throws	定义方法可能抛出的异常
transient	修饰不要序列化的字段
try	表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
void	标记方法不返回任何值
volatile	标记字段可能会被多个线程同时访问，而不做同步
while	while循环

---

自动类型转换

整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。

转换从低级到高级。

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

数据类型转换必须满足如下规则：

• 1. 不能对boolean类型进行类型转换。

• 2. 不能把对象类型转换成不相关类的对象。

• 3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。

• 4. 转换过程中可能导致溢出或损失精度，例如：

  int i =128;   
  byte b = (byte)i;

  因为byte类型时8位，最大值为127，所以当强制转换为int类型值128时候就会导致溢出。

• 5. 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：

  (int)23.7 == 23;		
  (int)-45.89f == -45

 

 

引用类型是一个对象类型，它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。

 

int a；  
a = 250； // 声明变量a的同时，系统给a分配了空间。

 

引用类型就不是了，只给变量分配了引用空间，数据空间没有分配，因为不知道数据是什么。

 

错误的例子：

 

MyDate today；
today.day = 4； // 发生错误，因为today对象的数据空间未分配。

 

引用类型变量在声明后必须通过实例化开辟数据空间，才能对变量所指向的对象进行访问。

 

MyDate today；          //将变量分配一个保存引用的空间
today = new MyDate（）；     // 这句话是2步，首先执行new MyDate（），给today变量开辟数据空间，然后再执行赋值操作

 

引用变量赋值：

 

MyDate a，b；        // 在内存开辟两个引用空间
a = new MyDate（）；      // 开辟MyDate对象的数据空间，并把该空间的首地址赋给a
b = a；                  // 将a存储空间中的地址写到b的存储空间中

 

 

java 实例变量在整个类内部是可访问的，而不管实例变量声明在类的哪个位置。

import java.io.*;

public class Employee{

	public Employee (String empName){
		name = empName;
	}
	
	public void setSalary(double empSal){
		salary = empSal;
	}
	
	public void printEmp(){
		System.out.println("name:" + name);
		System.out.println("salary:" + salary);
	}
	
	public static void main(String args[]){
		Employee empOne = new Employee("RUNOOB");
		empOne.setSalary(1000);
		empOne.printEmp();
		System.out.println(empOne.salary);
	}
	public String name;
	private double salary;
}

比如在上面代码中，尽管实例变量声明在类的尾部，在之前方法中仍可访问。

• 无final修饰，声明时赋值，构造器中赋值，静态语句块或静态方法赋值
• 有final修饰，声明时赋值，声明与赋值分开可在静态语句块中赋值

public class StaticTest {
	private static int staticInt = 2;
	private int random = 2;

	public StaticTest() {
		staticInt++;
		random++;
	}

	public static void main(String[] args) {
		System.out.println("类变量与对象变量的值变化");
		StaticTest test = new StaticTest();
		System.out.println("  实例1：staticInt:" + test.staticInt + "----random:" + test.random);
		StaticTest test2 = new StaticTest();
		System.out.println("  实例2：staticInt:" + test.staticInt + "----random:" + test.random);
		System.out.println("静态变量赋值");
		System.out.println("  静态语句块起作用:" + A.staticA);
		A a = new A();
		System.out.println("  构造器起作用:" + a.staticA);
		a.toChange();
		System.out.println("  静态方法1起作用:" + A.staticA);
		a.toChange2();
		System.out.println("  静态方法2起作用:" + A.staticA);
		System.out.println("常量赋值");
		System.out.println("  静态语句赋值:" + B.staticB);
	}
}

class A { 
	public static  String  staticA ="A" ;  
	//静态语句块修改值 
	static{  staticA ="A1"; } 
	//构造器修改值
	public A (){  staticA ="A2"; } 
	//静态方法起作用 
	
	public static void toChange(){  staticA ="A3"; } 
	public static void toChange2(){  staticA ="A4"; }  
}

class B { 
	public static final String  staticB ;  // 声明与赋值分离 
	static{  staticB ="B"; }
}

类变量可在类中直接使用，实例变量需实例化后才能使用。

public class StaticTest {
	private static int staticInt = 2;
	private int random = 2;

	public static void main(String[] args) {
		System.out.println(staticInt);
		StaticTest test = new StaticTest();
		System.out.println(test.random);
	}
}

来源：https://www.cnblogs.com/tianzijiaozi/p/7305942.html