初识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. 方法
  9. 重载
  • 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 类型，所以返回真
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/dear_diary/p/6492305.html