java学习笔记

基本语法

• 大小写敏感:java是大小写敏感的,这就意味着标识符Hello与hello是不一样的
• 类名:对所有的类说,类名的首字母应该是大写.
• 方法名:所有方法名必须小写字母开头
• 源文件:源文件名必须与类名相同
• 主方法入口:所有的java程序有

public static void main(String []args)方法开始执行

java标识符

• 所有组成部分都需要名字,类名,变量名,以及方法名都被称为标识符
• 关于标识符,有以下几点需要注意:
  
  • 所有的标识符都应该以字母(A-Z),美元符$.或者下划线开始
  • 首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合
  • 关键字不能作为标识符
  • 标识符是大小写敏感的
  • 合法标识符:age、$salary、_value、__1_value
  • 非法标识符:123abc、-salary

java修饰符

• java可以使用修饰符来修饰类中的方法和属性,主要分两类:
  
  • 访问控制修饰符:default, public , protected, private
  • 菲访问控制修饰符:final, abstract, strictfp

java变量

• 局部变量
• 类变量(静态变量)
• 成员变量(非静态变量)

java数组

• 数组是存储在堆上的对象,可以保存多个类型变量

java枚举

class FreshJuice {   enum FreshJuiceSize{ SMALL, MEDIUM , LARGE }   FreshJuiceSize size;}public class FreshJuiceTest {   public static void main(String []args){      FreshJuice juice = new FreshJuice();      juice.size = FreshJuice.FreshJuiceSize.MEDIUM  ;   }}

java关键字

关键字 描述 abstract 抽象方法，抽象类的修饰符 assert 断言条件是否满足 boolean 布尔数据类型 break 跳出循环或者label代码段 byte 8-bit有符号数据类型 case switch语句的一个条件 catch 和try搭配捕捉异常信息 char 16-bit Unicode字符数据类型 class 定义类 const 未使用 continue 不执行循环体剩余部分 do switch语句中的默认分支 double 循环语句，循环体至少会执行一次 else if条件不成立时执行的分支 enum 枚举类型 extends 表示一个类是另一个类的子类 final 1.表示一个值在初始化之后就不能再改变了 2.表示方法不能被重写，或者一个类不能有子类 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循环

java继承

• 在Java中，一个类可以由其他类派生。如果你要创建一个类，而且已经存在一个类具有你所需要的属性或方法，那么你可以将新创建的类继承该类。
• 利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。被继承的类称为超类（super class），派生类称为子类（subclass）。

接口

• 在Java中，接口可理解为对象间相互通信的协议。接口在继承中扮演着很重要的角色。
• 接口只定义派生要用到的方法，但是方法的具体实现完全取决于派生类。

Java 源程序与编译型运行区别

Java对象和类

• java作为一种面向对象语言,支持以下基本概念:
  
  • 多态
  • 继承
  • 封装
  • 抽象
  • 类
  • 对象
  • 实例
  • 方法
  • 重载
• 重点概念
  
  • 对象: 对象是类的一个实例,有状态和行为.例如:一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
  • 类: 类是一个模板,它描述一类对象行为和状态.
• 类型变量:
  
  • 局部变量: 在方法,构造方法或者语句块中定义的变量被称为局部变量,声明和初始化都在方法中,方法结束后,变量会自定销毁.
  • 成员变量: 成员变量是在定义类中,方法体之外的变量,这种变量在创建对象的时候实例化,成员变量可以被类中方法,构造方法和特定的语句块访问.
  • 类变量: 类变量也声明在类中,方法体之外,但必须声明为static类型

构造方法

- 每个类都有构建方法,如果没有显示的为类定义构建方法,java编译器将会为该类提供一个默认的构造方法.创建一个对象的时候,至少调用一个构造方法.构造方法的名称必须和类名相同,且一个类可以有多个构造方法- 代码示例:

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

创建对象

• 声明:声明一个对象,包括对象名称和对象类型
• 实例化:使用关键字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" );   }}

访问实例变量和方法

• 通过已创建的对象来访问成员变量和成员方法
• 代码示例:

/* 实例化对象 */ObjectReference = new Constructor();/* 访问其中的变量 */ObjectReference.variableName;/* 访问类中的方法 */ObjectReference.MethodName();

实例

• 代码示例:

public class Puppy{   int puppyAge;   public Puppy(String name){      // 这个构造器仅有一个参数：name      System.out.println("小狗的名字是 : " + name );    }   public void setAge( int age ){       puppyAge = age;   }   public int getAge( ){       System.out.println("小狗的年龄为 : " + puppyAge );        return puppyAge;   }   public static void main(String []args){      /* 创建对象 */      Puppy myPuppy = new Puppy( "tommy" );      /* 通过方法来设定age */      myPuppy.setAge( 2 );      /* 调用另一个方法获取age */      myPuppy.getAge( );      /*你也可以像下面这样访问成员变量 */      System.out.println("变量值 : " + myPuppy.puppyAge );    }}

源文件声明规则

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

Java包

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

import语句

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

一个简单的例子

• Employee.java 文件代码:

import java.io.*;public class Employee{   String name;   int age;   String designation;   double salary;   // Employee 类的构造器   public Employee(String name){      this.name = name;   }   // 设置age的值   public void empAge(int empAge){      age =  empAge;   }   /* 设置designation的值*/   public void empDesignation(String empDesig){      designation = empDesig;   }   /* 设置salary的值*/   public void empSalary(double empSalary){      salary = empSalary;   }   /* 打印信息 */   public void printEmployee(){      System.out.println("名字:"+ name );      System.out.println("年龄:" + age );      System.out.println("职位:" + designation );      System.out.println("薪水:" + salary);   }}

• EmployeeTest.java 文件代码：

import java.io.*;public class EmployeeTest{   public static void main(String args[]){      /* 使用构造器创建两个对象 */      Employee empOne = new Employee("RUNOOB1");      Employee empTwo = new Employee("RUNOOB2");      // 调用这两个对象的成员方法      empOne.empAge(26);      empOne.empDesignation("高级程序员");      empOne.empSalary(1000);      empOne.printEmployee();      empTwo.empAge(21);      empTwo.empDesignation("菜鸟程序员");      empTwo.empSalary(500);      empTwo.printEmployee();   }}

• 运行结果:

$ javac EmployeeTest.java$ java EmployeeTest 名字:RUNOOB1年龄:26职位:高级程序员薪水:1000.0名字:RUNOOB2年龄:21职位:菜鸟程序员薪水:500.0

java基本数据类型

• 变量就是申请内存来储值.创建变量的时候,需要在内存中申请空间,内存管理系统会根据变量的类型为变量分配存储空间,分配的空间只能用来储存该类型数据
• 如图:

- 因此通过定义不同的类型变量,可以在内存中储存整数,小数或字符串
- java的两大数据类型:
- 内置数据类型
- 引用数据类型

内置数据类型

• java语言提供了8种基本类型.6种数字类型(4个整数型,2个浮点型),1种字符类型,布尔类型

• byte:

  • byte 数据类型是8位,有符号的,以二进制补码表示的整数;
  • 最小值是-128(-2^7);
  • 最大值是127(2^7-1);
  • 默认值是0;
  • byte类型用在大型数组中节约空间,主要代替整数,因为byte变量占用的空间只有int类型的四分之一
  • 例子:byte a = 100, byte b = -50;

• short:

  • short数据类型是16位,有符号的以二进制补码表示的整数
  • 最小值是-32768(-2^15);
  • 最大值是32767(2^15 - 1);
  • short数据类型也可以像byte那样节省空间,一个short变量是int型变量所占空间的二分之一;
  • 默认值是0;
  • 例子: short s = 1000, short r = -20000;

• int

  • int 数据类型是32位、有符号的以二进制补码表示的整数；
  • 最小值是 -2,147,483,648（-2^31)；
  • 最大值是 2,147,483,647（2^31 - 1）；
  • 一般地整型变量默认为 int 类型；
  • 默认值是 0 ；
    -例子：int a = 100000, int b = -200000。

• long

  • long 数据类型是 64位、有符号的以二进制补码表示的整数
  • 最小值是-9,223,372,036,854,775,808(-2^63);
  • 最大值是9,223,372,036,854,775,807(2^63 - 1);
  • 默认值是0L;
  • 这种类型主要使用在需要比较大整数的系统上;
  • 例子： long a = 100000L，Long b = -200000L。”L”理论上不分大小写,但是若写成”l”容易与数字”1”混淆,不容易分辨,最好大写

• float

  • float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
  • float 在储存大型浮点数组的时候可节省内存空间；
  • 默认值是 0.0f；
  • 浮点数不能用来表示精确的值，如货币；
  • 例子：float f1 = 234.5f。

• double

  • double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
  • 浮点数的默认类型为double类型；
  • double类型同样不能表示精确的值，如货币；
  • 默认值是 0.0d；
  • 例子：double d1 = 123.4。

• boolean

  • boolean数据类型表示一位的信息；
  • 只有两个取值：true 和 false；
  • 这种类型只作为一种标志来记录 true/false 情况；
  • 默认值是 false；
  • 例子：boolean one = true。

• char

  • char类型是一个单一的 16 位 Unicode 字符；
  • 最小值是 \u0000（即为0）；
  • 最大值是 \uffff（即为65,535）；
  • char 数据类型可以储存任何字符；
  • 例子：char letter = ‘A’;

实例

• 对于数值类型的基本类型的取值范围，我们无需强制去记忆，因为它们的值都已经以常量的形式定义在对应的包装类中了。请看下面的例子：
• 示例代码:

public class PrimitiveTypeTest {      public static void main(String[] args) {          // byte          System.out.println("基本类型：byte 二进制位数：" + Byte.SIZE);          System.out.println("包装类：java.lang.Byte");          System.out.println("最小值：Byte.MIN_VALUE=" + Byte.MIN_VALUE);          System.out.println("最大值：Byte.MAX_VALUE=" + Byte.MAX_VALUE);          System.out.println();          // short          System.out.println("基本类型：short 二进制位数：" + Short.SIZE);          System.out.println("包装类：java.lang.Short");          System.out.println("最小值：Short.MIN_VALUE=" + Short.MIN_VALUE);          System.out.println("最大值：Short.MAX_VALUE=" + Short.MAX_VALUE);          System.out.println();          // int          System.out.println("基本类型：int 二进制位数：" + Integer.SIZE);          System.out.println("包装类：java.lang.Integer");          System.out.println("最小值：Integer.MIN_VALUE=" + Integer.MIN_VALUE);          System.out.println("最大值：Integer.MAX_VALUE=" + Integer.MAX_VALUE);          System.out.println();          // long          System.out.println("基本类型：long 二进制位数：" + Long.SIZE);          System.out.println("包装类：java.lang.Long");          System.out.println("最小值：Long.MIN_VALUE=" + Long.MIN_VALUE);          System.out.println("最大值：Long.MAX_VALUE=" + Long.MAX_VALUE);          System.out.println();          // float          System.out.println("基本类型：float 二进制位数：" + Float.SIZE);          System.out.println("包装类：java.lang.Float");          System.out.println("最小值：Float.MIN_VALUE=" + Float.MIN_VALUE);          System.out.println("最大值：Float.MAX_VALUE=" + Float.MAX_VALUE);          System.out.println();          // double          System.out.println("基本类型：double 二进制位数：" + Double.SIZE);          System.out.println("包装类：java.lang.Double");          System.out.println("最小值：Double.MIN_VALUE=" + Double.MIN_VALUE);          System.out.println("最大值：Double.MAX_VALUE=" + Double.MAX_VALUE);          System.out.println();          // char          System.out.println("基本类型：char 二进制位数：" + Character.SIZE);          System.out.println("包装类：java.lang.Character");          // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台          System.out.println("最小值：Character.MIN_VALUE="                  + (int) Character.MIN_VALUE);          // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台          System.out.println("最大值：Character.MAX_VALUE="                  + (int) Character.MAX_VALUE);      }  }

• 运行结果:

基本类型：byte 二进制位数：8包装类：java.lang.Byte最小值：Byte.MIN_VALUE=-128最大值：Byte.MAX_VALUE=127基本类型：short 二进制位数：16包装类：java.lang.Short最小值：Short.MIN_VALUE=-32768最大值：Short.MAX_VALUE=32767基本类型：int 二进制位数：32包装类：java.lang.Integer最小值：Integer.MIN_VALUE=-2147483648最大值：Integer.MAX_VALUE=2147483647基本类型：long 二进制位数：64包装类：java.lang.Long最小值：Long.MIN_VALUE=-9223372036854775808最大值：Long.MAX_VALUE=9223372036854775807基本类型：float 二进制位数：32包装类：java.lang.Float最小值：Float.MIN_VALUE=1.4E-45最大值：Float.MAX_VALUE=3.4028235E38基本类型：double 二进制位数：64包装类：java.lang.Double最小值：Double.MIN_VALUE=4.9E-324最大值：Double.MAX_VALUE=1.7976931348623157E308基本类型：char 二进制位数：16包装类：java.lang.Character最小值：Character.MIN_VALUE=0最大值：Character.MAX_VALUE=65535

引用类型

• 引用类型的变量非常类似C/C++的指针.引用类型指向一个对象,指向对象的变量为引用变量,声明时会指定为特定的数据类型.且不能改变
• 对象,数组都是引用数据类型
• 引用类型的默认值为null
• 一个引用变量可以用来引用于任何与之兼容的类型

java常量

• 常量在程序运行时,不会被修改的量,在java中使用final关键字来修饰,使用大写字母表示常量
• 代码示例:

final double PI = 3.1415927;

• 字面量可以赋给任何内置类型的变量,例如:

byte a = 68;char a = 'A'

• byte,int,long,short都可以用十进制,16进制以及8进制的方式来表示
• 当使用常量的时候,前缀0表示8进制,0x表示16进制,例如:

int decimal = 100;int octal = 0144;int hexa =  0x64;

• 和其他语言一样,java的字符串常量也是包含在两个引导之间的字符序列,例如:

"Hello World""two\nlines""\"This is in quotes\""

• 字符串常量和字符常量都可以包含任何Unicode字符,例如:

char a = '\u0001';String a = "\u0001";

java语言支持一些特殊的转义字符序列

符号 字符含义 \n 换行(0x0a) \r 回车(0x0d) \f 换页符 \b 退格 \0 空格 \s 字符串 \t 制表符 \” 双引号 \’ 单引号 \ \ 反斜杠 \ddd 八进制字符 \uxxxx 16进制Unicode字符

自动类型转换

• 整型,实型(常量),字符型数据可以混合运算,运算中,不同类型的数据先转化为同一类型,然后进行运算

低  ------------------------------------>  高byte,short,char—> int —> long—> float —> double 

• 数据类型转换必须满足以下规则

  • 不能对boolean类型进行转换
  • 不能把对象类型转成不相关类对象
  • 在把容量大的类型转换成容量小的类型时,必须使用强制类型转换
  • 转换过程可能导致或损失精度
  • • 注意点: int i =128; byte b = (byte)i;
  • • 因为byte类型时8位，最大值为127，所以当强制转换为int类型值128时候就会导致溢出。
  • 浮点数到正式的转换是通过舍弃小数得到,而不是四舍五入
  • • (int) 23.7 == 23; (int) -45.89f == -45;

• 自动类型转换

  • 必须满足转换前的数据类型的位数要低于转换后的数据类型，例如: short数据类型的位数为16位，就可以自动转换位数为32的int类型，同样float数据类型的位数为32，可以自动转换为64位的double类型。
  • 代码示例:

public class ZiDongLeiZhuan{        public static void main(String[] args){            char c1='a';//定义一个char类型            int i1 = c1;//char自动类型转换为int            System.out.println("char自动类型转换为int后的值等于"+i1);            char c2 = 'A';//定义一个char类型            int i2 = c2+1;//char 类型和 int 类型计算            System.out.println("char类型和int计算后的值等于"+i2);        }}//运行结果char自动类型转换为int后的值等于97char类型和int计算后的值等于66解析：c1的值为字符'a',查ascii码表可知对应的int类型值为97，'A'对应值为65，所以i2=65+1=66。强制类型转换1. 条件是转换的数据类型必须是兼容的。2. 格式：(type)value type是要强制类型转换后的数据类型 实例：public class QiangZhiZhuanHuan{    public static void main(String[] args){        int i1 = 123;        byte b = (byte)i1;//强制类型转换为byte        System.out.println("int强制类型转换为byte后的值等于"+b);    }}//运行结果:int强制类型转换为byte后的值等于123

• 隐含强制类型转换
  
  • 1. 整数的默认类型是 int。
  • 1. 浮点型不存在这种情况4，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。