具备Python基础的Java快速通关手册（Python不涉及的知识）

一、Java中类的创建方式：

        1.类所包含的变量：

        ①局部变量：在方法、构造方法、或者语句块中定义的变量为局部变量。②成员变量：定义在类中，方法体以外的变量。③类变量：声明为static类型，在类中，方法体以外的变量。

        2.类的构造实例：

        首先使用public class创造了一个名为class的类，下面的语句中public为访问修饰符，static为关键字，void为返回类型，main为方法名，string[]说明对象为字符串型，args是数组。

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

二、Java中标识符的命名规则和修饰符分类： 

        1.Java标识符的规定：类名、变量名以及方法名都被称为标识符

        ①所有首字母只能是大小写的字母(A-Z或者a-z)、美元符号($)、或者下划线(_)开始,首字母之后也只能由这三类构成。②关键字不能用作标识符。③标识符大小写敏感。

        2.Java修饰符：Java可以通过修饰符来修饰类中的方法和属性

        常见可以分为“访问控制修饰符” 和“非访问控制修饰符”，访问控制修饰符可以是"default, public, protected, private",非访问控制修饰符为“final, abstract, static, synchronized”。

三、Java中对象的创建方式：

        1.创建对象的三个步骤：声明、实例化、初始化。

        ①声明：指的是声明一个对象，包括对象名称和对象类型。在下例中使用new语句对对象声明，形式为“类名 对象名 = new 类名();”,类名为Puppy,对象名为myPuppy,创建了一个含有字符串“tommy”的对象②实例化：指的是使用关键字new创造一个对象。③初始化：使用new创建对象的时候，会调用创造方法初始化对象。

        在下述的的代码中首先定义了类Puppy，再使用"public Puppy(String name)"对Puppy类创造了一个名为name的String类型的属性，用“System.out.println("小狗的名字是：" + name)”创造了一个输出函数,再使用“public static void main(string[] args)”定义了返回类型，方法名等参数。

public class Puppy{
   public Puppy(String name){
      //这个构造器仅有一个参数：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的语句将创建一个Puppy对象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}
//得到输出结果
小狗的名字是 : tommy

        2.访问实例变量和方法的途径： 

        首先我们使用public class创建了一个名为Puppy的类，然后再通过int语句把puppyAge这个变量转化为int型虚参，便于在下面的模块中传递实参。

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 ); 
   }
}

四、源文件的声明规则：

         在一个源文件中定义多个类，并且还有import语句和package语句时应该注意以下规则。①一个源文件中只能包含一个public类和多个非public类。②源文件的名称应该和public类的类名保持一致。③一个类的定义在某个包中，那么Package语句应该放在源文件首行。④源文件中包含import语句，应该放在package语句和类定义之间。

 五、Java基本数据类型：内置数据类型和引用数据类型

        1.内置数据类型：

            Java一共提供了八种基本的数据类型，六种数字类型（四个整数型和两个浮点型），一种字符类型和一种Bool型。其中byte,short,int,long分别是二进制8、16、32、64位的整数，byte，short可以节约计算机内存。float, double分别是单精度32位、双精度64位的浮点数。

        2.引用类型：

             Java中，引用类型的变量非常类似于C/C#的指针。引用类型指向一个对象，指向对象的变量是引用变量，这些变量一旦声明之后不能更改。对象和数组都是引用数据类型，且所有引用对象的默认值都是null。

        3.Java常量：

           Java常量在程序运行时不能修改，在Java中国通常使用final关键字来修饰常量，声明方式和变量类似，以"final 数据类型 变量名 =  数值"来赋值。

          当使用字面量时，前置"0"表示8进制，而前缀0x代表16进制。

int octal = 0144
int hexa = 0x64

        4.自动类型转化： 

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

           数据类型由低级向高级排序：byte,short,char—> int —> long—> float —> double

·        数据转化必须满足如下规则：①不能对boolean类型进行转化。②不能把1对象类型转化为不相关类的对象。③把容量大的类型转换为容量小的类型时，必须使用强制转化类型。④转化过程中可能导致一处或者损失精度。

         通过这个数据转化，我们实现了由char这种低容量的数据内存转变为int这种高容量的数据内存。char赋值c1的是字符串a，类型值为97，转化为int型后System.out.println()输出的数值为97。

public class Puppy {
    public static void main(String[] args) {
        char c1 = 'a';
        int i1 = c1;
        System.out.println("char类型自动转化为int后的值：" + i1);
    }
}

        强制类型转化要求转化的数据类型是兼容的，并且使用格式“byte g = (byte) c1”这种格式强制转化。下面这个例子中我们创建了一个int变量c1，通过强制转化变为一个低容量的byte型。

public class Puppy {
    public static void main(String[] args) {
        int c1 = 'b';
        byte g = (byte) c1;
        System.out.println("g输出的数值是：" + g);
    }
}

        5.Java变量的命名规则： 

        在Java中，对于不同类型的变量（实例变量、局部变量、静态变量）有一些命名规则和约定，遵循基本规则有利于代码后期的可读性以及维护性。变量命名时应注意区分大小写，避免以数字开头。对于不同类型的变量(局部变量、实例变量、静态变量)，可以采用不同的命名约定，使用前缀和后缀区分。对于实例变量和局部变量，多个单词组成的变量应该使用驼峰命名法，并且以小写字母开头。但是对于静态变量，使用驼峰命名法的时候以小写字母开头。

/*局部变量*/
int myLocalVariable;
/*实例变量(成员变量)*/
print int myInstanceVariable;
/*静态变量(类变量)*/
public static void myStaticVariable();

        对于常量，通常使用全大写字母，单词之间用下划线间隔。如下展示静态常量的命名方式(final语句)。

/*静态常量的命名方式*/
public static final double MY_PI = 3.14

        对于参数，应该使用驼峰命名法，并且和变量一样，以小写字母开头。 

public static void my_Girl(int myParameter){
    //方法体
}

六、Java修饰符：控制访问控制符对类、变量、方法和构造方法的访问。

        1. Java修饰符的分类：

          Java语言提供了很多修饰符，主要分为访问修饰符和非访问修饰符两类，修饰符用来定义类、方法或者变量，通常放在语句的最前端。

          Java中可以通过使用访问修饰符来保护对类、变量、方法和构造方法的访问，Java支持4种不同的访问权限。①default(默认，什么都不写)：在同一个包内，不使用任何修饰符，适用对象：类、接口、变量、方法。②private:在同一类内可见，适用对象：变量、方法。③public:对所有类课件，适用对象：类、接口、变量、方法。④protected:对同一包内的类和所有子类课件，适用对象：变量、方法。注意private修饰符所修饰的变量在子类种不可见。

        通过下述语句，即“Java修饰符 + 数据类型 + 变量”对变量进行修饰。

public class Puppy {
    /* 通过修饰符对变量的作用域进行规定 */
}

/* 依次创建作用在同一类的变量，默认变量，作用于同一类或者子类的变量 */
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;

public static void main(String[] args) {
    /* 方法体 */
}

        1.1私有访问修饰符的访问方法： 

          声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问，Private访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。 在下面的实例中，我们首先定义了一个私有访问变量Logger，只能通过public定义的方法进行访问，即“public String getFormat()”和"public void setFormat(String format)"。

public class Logger {
    private String format;

    public String getFormat() {
        return this.format;
    }

    public void setFormat(String format) {
        this.format = format;
    }
}

        1.2受保护的访问修饰符的访问方法（protected）： 

           受保护的访问修饰符的访问方法可以分为“子类和基类在同一个包内”和“子类和基类不在一个包内”两种类型。①子类和基类再同一个包内：被声明为protected的变量、方法和构造器能被同一个包内的其他类访问。 ②子类和基类不在同一个包内：在子类中，子类实例可以访问其他从基类继承而来的protected方法（注意是其他基类中的protected方法，不是子类中的protected方法），而不能访问基类实例的protected方法。

           如果把openSpeaker()方法命名为private，除了AudioPlayer外，其他类不能访问该方法。

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}
 
class StreamingAudioPlayer extends AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

        2.非访问修饰符： 

            除了访问修饰符之外，Java还提供了许多非访问修饰符。①static修饰符，用于修饰类、方法和类变量。static关键字用来声明独立于对象的静态变量，声明静态变量时，无论一个类实例化多少对象，它的静态变量只有一份拷贝。同时也声明静态方法，static关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。对静态变量和方法的访问可以直接使用classname.variablename和classname.methodname两个方法。

          在类InstanceCounter中，首先定义了一个变量和两个方法，都使用了静态修饰符static。再使用"public static void main(String[] args)"定义了一个索引静态变量和方法的方法体，使用了两个输出函数System.out.println(InstanceCounter.getCount())来调动静态函数。 

public class InstanceCounter {
    private static int numInstances = 0;

    protected static int getCount() {
        return numInstances;
    }

    private static void addInstance() {
        numInstances++;
    }

    InstanceCounter() {
        InstanceCounter.addInstance();
    }

    public static void main(String[] args) {
        System.out.println("Start with:" + InstanceCounter.getCount() + "instances");
        for (int i = 0; i < 500; ++i) {
            new InstanceCounter();
        }
        System.out.println("Created" + InstanceCounter.getCount() + "instances");
    }
//输出值
Start with:0instances
Created500instances

七、Java运算符：算数、关系、位、逻辑、赋值运算符 

        1.算数运算符： 

           除了常见的“加减乘除取余”的算数运算符之外，Java具备python没有的“自增++”和“自减--”，使用自增函数对变量的数值加1，使用自减函数对变量的数值减1。

public class Test {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println("++b = " + (++b));
        System.out.println("b++ = " + (b++));
        System.out.println("a-- =" + (a--));
        System.out.println("--a = " + (--a));
    }
}
//输出的数值
++b = 21
b++ = 21
a-- =10
--a = 8