初识Java

  • 第一个Java程序
  • public class HelloWorld {
        /* 第一个Java程序
         * 它将打印字符串 Hello World
         */
        public static void main(String []args) {
            System.out.println("Hello World"); // 打印 Hello World
        }
    }

     终端运行:

lujiafengdeMacBook-Pro:~ lujiafeng$ Javac HelloWorld.java
lujiafengdeMacBook-Pro:~ lujiafeng$ java HelloWorld

Hello World
  •  基本语法
  1. 大小写敏感:Java是大小写敏感的,这就意味着标识符Hello与hello是不同的。
  2. 类名:对于所有的类来说,类名的首字母应该大写。如果类名由若干单词组成,那么每个单词的首字母应该大写,例如 MyFirstJavaClass 。
  3. 方法名:所有的方法名都应该以小写字母开头。如果方法名含有若干单词,则后面的每个单词首字母大写。
  4. 源文件名源文件名必须和类名相同。当保存文件的时候,你应该使用类名作为文件名保存(切记Java是大小写敏感的),文件名的后缀为.java。(如果文件名和类名不相同则会导致编译错误)。
  5. 主方法入口:所有的Java 程序由public static void main(String []args)方法开始执行。
  • Java源程序与编译型运行区别:
  • Java是一种面向对象语言。支持以下基本概念:
  1. 多态
  2. 继承
  3. 封装
  4. 抽象
  5. 对象
  6. 实例
  7. 方法
  8. 重载
  • Java对象和类
  1. 对象是类的一个实例,有状态和行为。
  2. 类是一个模版,它描述一类对象的行为和状态。

一个简单的类:

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

 

创建对象:

  1. 声明:声明一个对象,包括对象名称和对象类型。
  2. 实例化:使用关键字new来创建一个对象。
  3. 初始化:使用new创建对象时,会调用构造方法初始化对象。

 

访问实例变量和方法:

/* 实例化对象 */
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 ); 
   }
}

 

编译运行:

小狗的名字是 : tommy
小狗的年龄为 : 2
变量值 : 2

 

  • 源文件声明规则
  1. 一个源文件中只能有一个public类
  2. 一个源文件可以有多个非public类
  3. 源文件的名称应该和public类的类名保持一致。例如:源文件中public类的类名是Employee,那么源文件应该命名为Employee.java。
  4. 如果一个类定义在某个包中,那么package语句应该在源文件的首行。
  5. 如果源文件包含import语句,那么应该放在package语句和类定义之间。如果没有package语句,那么import语句应该在源文件中最前面。
  6. import语句和package语句对源文件中定义的所有类都有效。在同一源文件中,不能给不同的类不同的包声明。
  • Java基本数据类型
  • 内置数据类型
  1. byte
  2. short
  3. int
  4. long
  5. float
  6. double
  7. boolean
  8. char
  • 引用数据类型
  • 在Java中,引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象,指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型,比如Employee、Pubby等。变量一旦声明后,类型就不能被改变了。
    • 对象、数组都是引用数据类型。
    • 所有引用类型的默认值都是null。
    • 一个引用变量可以用来引用与任何与之兼容的类型。
    • 例子:Site site = new Site("Runoob")。

 

  • Java常量

在 Java 中使用 final 关键字来修饰常量,声明方式和变量类似:

final double PI = 3.1415927;

 

byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。

当使用常量的时候,前缀0表示8进制,而前缀0x代表16进制。例如:

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

 

  • 自动类型转换

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

转换从低级到高级。

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

 

数据类型转换规则:

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

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

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

  4.  转换过程中可能导致溢出或损失精度。

  5. 浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入。

 

  • 强制类型转换
  • 隐含强制类型转换

 

  • Java局部变量
  1. 局部变量声明在方法、构造方法或者语句块中;
  2. 局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
  3. 访问修饰符不能用于局部变量;
  4. 局部变量只在声明它的方法、构造方法或者语句块中可见;
  5. 局部变量是在栈上分配的。
  6. 局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。
  • 实例变量
  1. 实例变量声明在一个类中,但在方法、构造方法和语句块之外;
  2. 当一个对象被实例化之后,每个实例变量的值就跟着确定;
  3. 实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
  4. 实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;
  5. 实例变量可以声明在使用前或者使用后;
  6. 访问修饰符可以修饰实例变量;
  7. 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
  8. 实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
  9. 实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。
  • 类变量(静态变量)
  1. 类变量也称为静态变量,在类中以static关键字声明,但必须在方法构造方法和语句块之外。
  2. 无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。
  3. 静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。
  4. 静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。
  5. 静态变量在程序开始时创建,在程序结束时销毁。
  6. 与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。
  7. 默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。
  8. 静态变量可以通过:ClassName.VariableName的方式访问。
  9. 类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。
  • Java修饰符
  1. 访问修饰符

Java中,可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。

默认的,也称为 default,在同一包内可见,不使用任何修饰符。

私有的,以 private 修饰符指定,在同一类内可见。

共有的,以 public 修饰符指定,对所有类可见。

受保护的,以 protected 修饰符指定,对同一包内的类和所有子类可见。

修饰符当前类同一包内子孙类其他包
public Y Y Y Y
protected Y Y Y N
default Y Y N N
private Y N N N
  • Java运算符
  1. 位运算符
A = 0011 1100
B = 0000 1101
-----------------
A&b = 0000 1100
A | B = 0011 1101
A ^ B = 0011 0001
~A= 1100 0011

 

短逻辑运算符

当使用与逻辑运算符时,在两个操作数都为true时,结果才为true,但是当得到第一个操作为false时,其结果就必定是false,这时候就不会再判断第二个操作了。

public class LuoJi{
    public static void main(String[] args){
        int a = 5;//定义一个变量;
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}
//运行结果
使用短路逻辑运算符的结果为false
a的结果为5

 

 条件运算符(?:)

条件运算符也被称为三元运算符。该运算符有3个操作数,并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。

 

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

 

 

public class Test {
   public static void main(String args[]){
      int a , b;
      a = 10;
      // 如果 a 等于 1 成立,则设置 b 为 20,否则为 30
      b = (a == 1) ? 20 : 30;
      System.out.println( "Value of b is : " +  b );
 
      // 如果 a 等于 10 成立,则设置 b 为 20,否则为 30
      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)

如果运算符左侧变量所指的对象,是操作符右侧类或接口(class/interface)的一个对象,那么结果为真。

下面是一个例子:

String name = "James";
boolean result = name instanceof String; // 由于 name 是 String 类型,所以返回真

 

posted @ 2017-03-02 20:02  dear_diary  阅读(345)  评论(0编辑  收藏  举报