Java基础

Java程序运行：

1，首先呢打开记事本创建一个.java文件；

2，在Java文件中输入：

public class Hello{
	public static void main(String[] args){
		System.out.println("hello world!!");
}
}

3,使用命令提示符到你文件目录下运行.Java文件，会生成一个.class文件；

4，运行.class文件会出现以下效果，至此一个简单的Java程序就完成啦。

5 注意哪些地方
(1) 修改系统设置，显示文件后缀名，重命名后的文件一定是.java结尾的
(2) 涉及到的符号要用英文半角的
(3) 有public class的时候，文件名要和公共类的类名要一致，首字母大写
(4) 打开文件路径时，不同盘符要切换盘符
(5) 运行的时候不带扩展名 java Hello

注意！！运行.class文件是一定要把后缀名去掉！！

以上运行效果需要装jdk并且配置jdk环境！！

Java严格区分大小写！！

个人认为初学的时候就应该多遇到点问题，坑踩得多了也就不怕坑了

注释

/*
1.Java规范的三种注释方式：
单行注释
多行注释
文档注释

2.
单行注释和多行注释的作用：
	1. 对所写的程序进行解释说明，增强代码的可读性。
	2. 调试所写代码

3，特点：单行注释和多行注释，其所注释的内容不参与编译；

4.文档注释的使用
	注释内容可以被JDK工具javadoc所解析，生成一个以网页形式所展现的程序说明文档。

5，多行注释不可以嵌套使用

JavaAPI文档

该文档提供了Java编程的基本接口（类库）我们将此称为API，就相当于我们学习中文时的字典

https://docs.oracle.com/javase/8/docs/api/

Java关键字和保留字

关键字（keyword）的定义和特点

定义：被Java语言赋予了特殊含义，用作专门用途的字符串；

特点：关键字中所有字母均为小写；

Java保留字（reserved word）

现有版本没有使用，但以后的版本可能会使用其作为关键字

goto、const

标识符

什么是标识符呢简单来说就是你自己起的名字，但是这个名字呢也要遵循一定的规范不要乱写，这里建议去查看《阿里巴巴Java开发手册》一书，请自行百度；

规则如下：

1 类名，变量名，方法名
2 第一个字符不能是数字
3 不能是java 关键字
4 严格区分大小写（oracle数据库不区分）name Name
5 标识符没有长度限制(校区班级学生名 schoolClassStudent)
6 java语言采取unicode 编码方式，不局限于26个英文字母，
7 $ _可以有

变量

概念：

• 内存中的一个存储区域
• 该区域的数据可以在同一类型范围内不断变化
• 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

作用：

用于在内存中保存数据

注意：

• Java中每个变量必须先声明，后使用
• 使用变量名来访问这块区域的数据
• 变量的作用域：只存在{}中
• 变量只有在其作用域内生效
• 同一个作用域内，不能定义相同的变量名

基本数据类型

整型 ：byte,short,int,long
浮点型 ：float,double
字符型 ：char
布尔型 ：boolean

引用数据类型

类,接口,数组,枚举

类型转换

类型转换分类显式类型转换和隐式类型转换

隐式 自动转换 由低到高 穷人变富人
显式 强制转换 由高到低 富人变穷人 精度丢失 (数据类型)变量

字符串类型String

• String不是基础数据类型
• 使用方式与基本数据类型一致
• 一个字符串可以拼接另一个字符串，也可以拼接其他类型的数据

进制

运算符

算术运算符

算术运算符在数学表达中的使用和它们在代数中的使用是相同的。下面的表格列举了算数运算符：

关系运算符

位运算符

Java 定义了几种运算符，这类运算符可被运用于整数型式，long, int，short，字符型和字节型。

逻辑运算符

赋值运算符

三元运算符（条件表达式）？表达式1：表达式2

这种运算符由三个操作数组成，被用作评估布尔数学体系表达。这种运算符的目的是来决定哪些值应被赋予到变量上。这个运算符被写作如下：

variable x = (expression) ? value if true : value if false 

public class Test {

   public static void main(String args[]){
      int a , b;
      a = 10;
      b = (a == 1) ? 20: 30;
      System.out.println( "Value of b is : " +  b );

      b = (a == 10) ? 20: 30;
      System.out.println( "Value of b is : " + b );
   }
}

Value of b is : 30
Value of b is : 20

Instanceof 符

这种操作符只用于对象引用变量。这种操作符检查对象是否是独特类型（类型或接口类型）。Instanceof 运算符写为：

( Object reference variable ) instanceof  (class/interface type)

如果在运算符左侧的由变量所指代的对象为右侧的类型或接口类型通过 IS-A 检查，那么结果为真。以下是示例：

public class Test {

   public static void main(String args[]){
      String name = "James";
      // following will return true since name is type of String
      boolean result = name instanceof String;  
      System.out.println( result );
   }
}

这就会产出如下结果：

true

这种运算符仍会返回到真如果被比较的对象是与右边类型兼容的赋值。以下是另一个例子：

class Vehicle {}

public class Car extends Vehicle {
   public static void main(String args[]){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result );
   }
}

这样将会产生以下的结果：

true

Java 运算符的优先级

运算符优先级决定一个表达式里术语的分组。它影响着一个表达式如何求值。一定的运算符比其他运算符拥有更高的优先级；例如：乘法运算符比加法运算符有更高的优先级：

例如，x=7+3 *2; 这里x 被赋值为13，不是20，是因为运算符 比运算符+由更高的优先级， 所以它首先运算乘法 32, 然后再加7。

这里，有着最高优先级的运算符在这个表格的最高一层，最低优先权的则出现在最底部。在一个表达式中，越高等级的优先权的运算符会最先被求值。

本节摘自这里

流程控制

分支结构

if--else

测试：

switch-case

测试：

注意！！switch结构的表达式只能为byte、short、char、int、枚举（JDK5.0) 、String类型（JDK7.0)

循环结构

for循环

for(表达式1;表达式2;表达式3){

}

表达式1 ：初始化语句 int num = 0;
表达式2 ：条件表达式 num <520;
表达式3 ：迭代语句 num++;

while循环

结构：
while(条件表达式){
}

do--while循环

do{

}

while(条件表达式);

break 关键字

关键字break是用来停止整个循环的。 break关键字必须使用于任何循环中或一个switch语句中。

关键字break将停止最内层循环的执行，并开始执行在块之后的下一行代码。

语法

break语法是任何循环中一个单独的语句：

break

示例

public class Test {

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         if( x == 30 ) {
          break;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

这将产生以下结果:

10
20

continue 关键字

continue关键字可以在任一环的控制结构使用。它使循环立即跳转到循环的下一次迭代.

• 在for循环中，continue关键字会导致控制流立即跳转到更新语句。
• 在一个while循环或do/while循环，控制流立即跳转到布尔表达式。

语法

continue 语法是任何循环中一个单独的语句：

continue

示例

   public static void main(String args[]) {
      int [] numbers = {10, 20, 30, 40, 50};

      for(int x : numbers ) {
         if( x == 30 ) {
          continue;
         }
         System.out.print( x );
         System.out.print("\n");
      }
   }
}

这将产生以下结果：

10
20
40
50

dowhile和for、while的区别：

dowhile是先执行后判断条件语句，至少会执行一次循环体

结束循环体的几种方式

• 循环条件部分返回false
• 在循环体中执行break

数组

数组（Array),是多个相同数据类型按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

数组的常见概念：

• 数组名
• 下标（或索引）
• 元素
• 数组的长度

---------------------------------
|	张三	|	 李四	|	王五	|	赵六	|
---------------------------------
    0       1       2      3   （下标或者索引）
      
1 知道下标了，怎么找李四，找一号就行了 数组[1]
2 不知道下标，怎么找李四？
  
声明  
静态初始化  int[] a  = {1,2}；必须写在一行！！！
动态初始化  int [] a ;a = new int[5];

1数组.length  length是数组对象的一个属性，代表有几个数组元素，一般和循环搭配使用
2最大的下标 数组.length-1


赋值: 
数组[下标的值]= 对应类型的值


数组动态初始化的时候赋初值
整形 0
浮点 0.0
布尔型的 false
其它的都是null

foreach 循环

JDK 1.5 引入了一个新的 for 循环被称为 foreach 循环或增强的 for 循环，它无需使用一个索引变量来完整的遍历数组。

示例

下面的代码显示数组 myList 中的所有元素：

public class TestArray {

   public static void main(String[] args) {
      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // Print all the array elements
      for (double element: myList) {
         System.out.println(element);
      }
   }
}

这将产生以下结果:

1.9
2.9
3.4
3.5

将数组传递给方法

正如传递基本类型值的方法，也可以将数组传递给方法。例如，下面的方法显示在一个 int 数组中的元素：

public static void printArray(int[] array) {
  for (int i = 0; i < array.length; i++) {
    System.out.print(array[i] + " ");
  }
}

你可以通过传递数组调用它。例如，下面的语句调用方法 PrintArray 显示3，1，2，6，4，2：

printArray(new int[]{3, 1, 2, 6, 4, 2});

从一个方法返回一个数组

一个方法也可以返回一个数组。例如，下面所示的方法返回一个数组，它是另一个数组的反转：

public static int[] reverse(int[] list) {
  int[] result = new int[list.length];

  for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
    result[j] = list[i];
  }
  return result;
}

二维数组

-------------------------------------------------

|	一维数组	|	一维数组	|	一维数组	|	一维数组	|

-------------------------------------------------
    0       1       2      3   （下标或者索引）
    
类比一下，火车上一节做了一个人，每个人都带了几本书。[书理解为一个数组]