【JAVA】Java 基础语法

类

类是同一类事物的统称；是封装对象的属性和行为的载体　　　　

成员方法语法格式

权限修饰符  返回值类型  方法名(参数类型  参数名){
    ……    //方法体
    return 返回值;
}

权限修饰符

主要包括：private、public和protected，这些修饰符控制着对类和类的成员变量以及成员方法的访问。

　　　　private

　　　　　　修饰成员变量和成员方法：则该成员只能在本类中使用，在子类中是不可见的，对其他包的类也是不可见的。

　　　　　 修饰类：这个类将隐藏其中所有的数据，防止用户直接访问该类。

　　　　public

　　　　　　修饰成员变量和成员方法：除了可以在本类访问使用这些数据，还可以在子类和其他包的类中使用。

　　　　　　修饰类：类中的数据可以被子类和其他包的类访问。

　　　　protected

　　　　　　修饰类的时候，只有本包内的该类的子类和其他类可以访问该类中的成员变量和成员方法。

this关键字

　　用于表示本类当前的对象，这个当前对象不是某个new出来的实体对象，而是当前正在编辑的类。<this关键字只能在本类中使用 >

源文件

　　类文件源文件名必须和类名相同，文件后缀.java

// HelloWorld.java
// java程序区分大小写，且语句末尾必须加 分号；
// 文件中存在 public class 时 文件名应和类名匹配；否则文件名可为其他
public class HelloWorld {

    public static void main(String[] args){
        // 换行输出
        System.out.print("Hello world");
    }
}

编译执行：

主方法入口

　　所有的 Java 程序由 public static void main(String[] args) 方法开始执行。

public class HelloWorld {

    /* java程序的必须部分（java程序处理从main()开始）
     * public static void main(String[] args)
     * 访问修饰符 关键字 返回类型 方法名 String类 字符串数组
     */
    public static void main(String[] args){
        // 换行输出
        System.out.print("Hello world");
    }
}

编译执行：

对象

public class HelloWorld {
    // 创建对象
    public void Hello(String name){
        System.out.println("My name is " + name + " !");
    }

    public static void main(String[] args){
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.Hello("body");
    }
}

编译结果：　　

构造对象

　　构造方法的名称必须与类同名，一个类可以有多个构造方法

　　没有显式地为类定义构造方法，则默认构造方法为空　　

示例1：

public class HelloWorld {

    // 构造方法
    public HelloWorld(){
        String age = "age";
        System.out.println(age);
    }

    public void Hello(String name){
        System.out.println("My name is " + name + " !");
    }

    public static void main(String[] args){
        // 下面的语句将创建一个Puppy对象
//        HelloWorld myHelloWorld = new HelloWorld();

        // 实例化
        HelloWorld helloWorld = new HelloWorld();
        helloWorld.Hello("body");
    }
}

编译结果：　　

示例2：

public class HelloWorld {
    // 创建对象
    public HelloWorld(String name){
        // 构造方法 仅有一个参数name
        System.out.println("My name is " + name + " !");
    }

    public static void main(String[] args){
        // 下面的语句将创建一个Puppy对象
        HelloWorld myHelloWorld = new HelloWorld("Tom");
}

编译结果：　　

标识符

　　Java 中所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符

　　规则：

　　　　1> 组成结构：字母、数字、下划线、$

2> 数字不能开头

3> 不能使用关键字

修饰符

　　用来修饰类中方法和属性，主要分为两类

　　　　访问控制修饰符 : 　　default, public , protected, private　　

　　　　　　default　对包可见，无关键字(不指定修饰符) 。

　　　　　　private　　仅对类内部可见。

　　　　　　public　　对所有可见。

　　　　　　protected　　对包和所有子类可见。

　　　　非访问控制修饰符 : final, abstract, static, synchronized

　　　　　　用于创建类方法和变量的static修饰符。

　　　　　　用于完成类，方法和变量的实现的final修饰符。

　　　　　　用于创建抽象类和方法的abstract修饰符。

　　　　　　synchronized和volatile修饰符，用于线程。

在超类中声明为public的方法也必须在所有子类中都是public。
在超类中声明为protected的方法必须在子类中也要声明为：protected或public; 不能声明为：private。
声明为private的方法根本不能被继承，因此没有规则

`命名规范`

1> 必须是合法的标识符

2> 起名要有意义，根据名称了解内容

3> 类名、接口名各个单词首字母要大写

4> 方法名、属性名单词首字母小写,之后各个单词首字母大写

5> 常量字母全部大写,多个单词使用下划线分隔

6> 包名全部小写,多层包使用"."分隔

7> 局部变量简单即可

大小写敏感

类名：首字母大写的驼峰式

方法名：首字母小写的驼峰式

源文件名：必须和类名相同

`关键字`

1> java中具有特殊用途的保留字

2> 关键字必须全部小写

　　　　PS： null 不是关键字，类似于 true 和 false，它是一个字面常量，不允许作为标识符使用

访问控制    
    private    私有的
    protected    受保护的
    public    公共的
    default    默认
    
类、方法和变量修饰符    
    abstract    声明抽象
    class    类
    extends    扩充,继承
    final    最终值,不可改变的
    implements    实现（接口）
    interface    接口
    native    本地，原生方法（非 Java 实现）
    new    新,创建
    static    静态
    strictfp    严格,精准
    synchronized    线程,同步
    transient    短暂
    volatile    易失
    
程序控制语句    
    break    跳出循环
    case    定义一个值以供 switch 选择
    continue    继续
    default    默认
    do    运行
    else    否则
    for    循环
    if    如果
    instanceof    实例
    return    返回
    switch    根据值选择执行
    while    循环
    
错误处理    
    assert    断言表达式是否为真
    catch    捕捉异常
    finally    有没有异常都执行
    throw    抛出一个异常对象
    throws    声明一个异常可能被抛出
    try    捕获异常
    
包相关    
    import    引入
    package    包
    
基本类型    
    boolean    布尔型
    byte    字节型
    char    字符型
    double    双精度浮点
    float    单精度浮点
    int    整型
    long    长整型
    short    短整型
    
变量引用    
    super    父类,超类
    this    本类
    void    无返回值
    
保留关键字    
    goto    是关键字，但不能使用
    const    是关键字，但不能使用

常见关键字

`变量`　　

　　在程序运行过程中可以改变的量。，所有的变量在使用前必须声明

　　变量类型：局部变量、类变量（静态变量）、成员变量（非静态变量、实例变量）
　　　　　　

　　　　　　局部变量：类的方法中的变量。

　　　　　　类变量（静态变量）：独立于方法之外的变量，用 static 修饰。（非实例变量）

　　　　　　实例变量：独立于方法之外的变量，即在类中定义的变量且没有 static 修饰。

　　　　　　PS：方法也可以分为实例和非实例方法，带有static为非实例方法（即静态方法），否则为实例方法

　　调用方法：

　　　　非实例变量/方法：　类名.变量名/方法名

　　　　实例变量/方法：　　

　　　　　　类名类名别名 = new 类名();

　　　　　　类名别名.变量名/方法名

public class HelloWorld {
    public static int a = 0;   // 类变量(静态变量)

    public int b = 3;   // 对子类可见

    public String c = "Hello World ";    // 实例变量

    private String name;    // 仅在该类可见,若单个方法使用的变量可以转换为局部变量


    public void expOne(){
        this.name = "   Join";
        System.out.println(b + this.name);
    }

    public void expTwo(){
        this.name = "   Lucy";
        System.out.println(this.name);
    }

    // main() 主方法
    public static void main(String[] args){
        String v = " !~";    // 局部变量

        // 调用非实例（静态）变量/方法：类名.变量名
        String sp = HelloWorld.a + v;
        System.out.println(sp);

        // 调用实例变量/方法
        HelloWorld helloWorld = new HelloWorld();
        System.out.println(helloWorld.c + helloWorld.b);
        helloWorld.expOne();
        helloWorld.expTwo();
    }

}

编译执行：　　

`常量`

　　在程序运行过程中不可以改变的量。

　　常量有三种类型：静态常量、成员常量和局部常量　　（类似于变量）

　　实例常量需要实例化（不带static），非实例常量不需要实例化使用类名.常量名调用（带有static）

// 字面常量 : 
    "abc" , 123
// 字符常量 : 使用final关键字定义的
     final int b = 15;

public class HelloWorld {

    public static final int a = 10;

    public final String b = "字符串";

    final String name = "mini";

    // main() 主方法
    public static void main(String[] args){
        final String c = "局部常量";    // 局部常量

        System.out.println("调用非实例常量：" + HelloWorld.a);

        System.out.println("调用局部常量：" + c);

        HelloWorld helloWorld = new HelloWorld();
        System.out.println("调用实例常量：" + helloWorld.b + helloWorld.name);
    }
}

编译执行：　　

基础数据类型

　　数值型
　　　　整型
　　　　byte 1个字节
　　　　short 2个字节
　　　　int 4个字节
　　　　long 8个字节
　　浮点型
　　　　float 4个字节
　　　　double 8个字节
　　字符型
　　　　char 表示形式 'a' '\u四位十六进制数' --> '\u0B23' '中' unicode
　　布尔型
　　　　boolean 取值 true false
　　引用数据类型
　　　　数组
　　　　类类型
　　　　接口类型

　　补充:
　　　　1> 在Java中整型默认使用的是int类型浮点型默认使用的是double类型,如果想使用float则在数值后加f(F)。如果想使用long类型则数值后l(L).
　　　　2>计算机中数值可以以八进制、十进制、十六进制表示
　　　　　　八进制 0数值 --> 0123
　　　　　　十六进制 0x数值 --> 0x123