前文中我们介绍了很多关于Java的一些语法知识，基础点，我们本期文章就把之前没有讲到的再说一次，然后以我自己理解的文字型的方式总结归纳一下。

Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作

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

初识Java之基础语法篇（下）_java
类变量的渗入

成员变量和类变量都是在方法之外，简单来说就是main（）的外面，此外成员变量需要在方法内进行实例化操作，就和我们Python实例化的概念差不多。

创建对象

声明一个对象，包括对象名称和对象类型。
使用关键字 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" );
   }
}

访问实例变量和方法

/* 实例化对象 */
Object referenceVariable = new Constructor();
/* 访问类中的变量 */
referenceVariable.variableName;
/* 访问类中的方法 */
referenceVariable.methodName();
package com.company;

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

初识Java之基础语法篇（下）_修饰符_02

一个源文件中只能有一个 public 类
初识Java之基础语法篇（下）_类_03

一个源文件可以有多个非 public 类

类的高级用法
第一步先自己写好一个方法，后面我们自己好调用

package com.company;


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

这里写好了方法，那么只需要后面我们自己再去写一个程序进行实例化操作就可以了。对于里面的this我们要记住这个是指向当前对象的引用！！！

package com.company;
import java.io.*;
public class EmployeeTest{

    public static void main(String[] args){
        /* 使用构造器创建两个对象 */
        Employee empOne = new Employee("王小王-1");
        Employee empTwo = new Employee("王小王-2");

        // 调用这两个对象的成员方法
        empOne.empAge(26);
        empOne.empDesignation("爬虫工程师");
        empOne.empSalary(20000);
        empOne.printEmployee();

        empTwo.empAge(21);
        empTwo.empDesignation("数据分析师");
        empTwo.empSalary(25000);
        empTwo.printEmployee();
    }
}

我们来看看效果

初识Java之基础语法篇（下）_多态_04这里我们就可以充分的理解了Java对于类的叠加是如此的强大了

引用类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。

例如：
Site site = new Site(“Runoob”)

常量在程序运行时是不能被修改的。

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

final double PI = 3.1415927;

数据类型转换必须满足如下规则：

  1. 不能对boolean类型进行类型转换。
  2. 不能把对象类型转换成不相关类的对象。
  3. 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
  4. 转换过程中可能导致溢出或损失精度。

如果要进行强制的转换就需要在前面加一个括号

public class QiangZhiZhuanHuan{
    public static void main(String[] args){
        int i1 = 123;
        byte b = (byte)i1;//强制类型转换为byte
        System.out.println("int强制类型转换为byte后的值等于"+b);
    }
}

实例变量

package 基础语法;

public class 实例变量 {
    // 这个实例变量对子类可见
    public String name;
    // 私有变量，仅在该类可见
    private double salary;
    //在构造器中对name赋值
    public 实例变量 (String empName){
        name = empName;
    }
    //设定salary的值
    public void setSalary(double empSal){
        salary = empSal;
    }
    // 打印信息
    public void printEmp(){
        System.out.println("名字 : " + name );
        System.out.println("薪水 : " + salary);
    }

    public static void main(String[] args){
        实例变量 empOne = new 实例变量("王小王");
        empOne.setSalary(10000.0);
        empOne.printEmp();
    }
}

初识Java之基础语法篇（下）_编程语言_05

这个程序首先声明了实例变量的属性，共同的，最后又声明了薪水的属性为私有的，但是在这个程序里面还是可以运行的。之后对每个变量进行赋值，这里之所以用public void 方法名（）{数据类型 变量名}是因为这里并没有返回值，所以我们用void关键字。

类变量（静态变量）

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
静态变量在第一次被访问时创建，在程序结束时销毁。

package 基础语法;
import java.io.*;
public class 静态变量 {
    //salary是静态的私有变量
    private static double salary;
    // DEPARTMENT是一个常量
    public static final String DEPARTMENT = "数据分析师";
    public static void main(String[] args){
        salary = 10000;
        System.out.println(DEPARTMENT+"平均工资:"+salary);
    }
}

初识Java之基础语法篇（下）_修饰符_06
Java修饰符

再次提醒！！！！！！！！！！

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

private
私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。
声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。

public class Logger {
   private String format;
   public String getFormat() {
      return this.format;
   }
   public void setFormat(String format) {
      this.format = format;
   }
}

实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）
public
被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。
如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

projected
子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

​​这个最难理解，详情点击了解​​

修饰符

这里只介绍一下static

package 基础语法;

public class 修饰符static {
    private static int numInstances = 0;
    protected static int getCount() {
        return numInstances;
    }

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

    修饰符static() {
        修饰符static.addInstance();
    }

    public static void main(String[] arguments) {
        System.out.println("Starting with " +
                修饰符static.getCount() + " instances");
        for (int i = 0; i < 500; ++i){
            new 修饰符static();
        }
        System.out.println("Created " +
                修饰符static.getCount() + " instances");
    }

}

初识Java之基础语法篇（下）_多态_07
运算符
不管是Java还是Python，或者是c运算符都是大同小异，我们要了解的可能和Python的有所不同。

这里要强调判断的是递增运算符合递减运算符，前++是先运算后赋值，并且改变原来的那个变量值。（原来的变量也改变了）
后++是先赋值后运算，那就是先把这个值打印出来，最后进行运算（改变最后本身值，原来的那个值也改变了）

package 基础语法;

public class 运算符 {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        System.out.println("a + b = " + (a + b) );
        System.out.println("a - b = " + (a - b) );
        System.out.println("a * b = " + (a * b) );
        System.out.println("b / a = " + (b / a) );
        System.out.println("b % a = " + (b % a) );
        System.out.println("c % a = " + (c % a) );
        System.out.println("a++   = " +  (a++) );
        System.out.println("a--   = " +  (a--) );
        // 查看  d++ 与 ++d 的不同
        System.out.println("d++   = " +  (d++) );
        System.out.println("++d   = " +  (++d) );
        System.out.println(++d);
    }
}

初识Java之基础语法篇（下）_java_08
初识Java之基础语法篇（下）_多态_09
初识Java之基础语法篇（下）_java_10
特别需要注意的是三元运算符

在之前的文章里面我也详细的介绍了

instanceof 运算符

String name = “James”;
boolean result = name instanceof String; // 由于 name 是 String 类型，所以返回真

class Vehicle {}
 
public class Car extends Vehicle {
   public static void main(String[] args){
      Vehicle a = new Car();
      boolean result =  a instanceof Car;
      System.out.println( result);
   }
}

true

Java运算符优先级

初识Java之基础语法篇（下）_修饰符_11
Java的基础语法不比得Python的简单易懂，我们这里总结了两篇，才结束，总的来说第一篇是泛泛而谈，第二篇是基础加实战操作，上图解释，希望大家在今后的学习中不断运用。

后期我们可能要学习方法和流程控制与语言结构。

每文一语

生活就是让我们感受快乐的，至于更高境界的快乐那就是意义所带来的愉悦了。