Java的基础语法就不像Python那样言简意赅，清楚明了。虽然Java是需要我们反复的去理解，才可以真正的认识到如何做到和Python的一样效果，但是只要你学进去了，最后发现基础依然是那些，只是站的高度不同罢了。
就好比如说Python的打印就只需要print（）函数即可，非常的简单，而Java是需要很多代码的。
给大家简单的看一个输入和输出的Java程序
引入
import java.util.Scanner;
public class study1 {
public static void main(String[] args){
Scanner scanner=new Scanner(System.in);
System.out.print("请输入一个数");
int a=scanner.nextInt();
System.out.printf("%d的平方是%d\n",a,a*a);
简单的描述一下就是，Java需要对类的属性了解到位，什么时候要用私有的，共同的，或者有时候需要定义变量，常量这些，都是和我们的Python的语法大相径庭的，所以在学习Java的过程中一定要掌握好基础的节奏，慢慢的去学。
public class HelloWorld {
/* 第一个Java程序
* 它将打印字符串 Hello World
*/
public static void main(String[] args) {
System.out.println("Hello World"); // 打印 Hello World
}
}
public static void main(String[]args){
System.out.println()；
}
一般主类都是有的，这个可能使我们自己要写的，熟记于心，而且每个后面的都需要加入分号！！！！！！！！！！！！
Java包
Java包是基础的一个概念，我们需要导入这个包的时候，依然用import+文件（包）这个的话需要去官网去了解一下，这里我就不做过多的叙述了。
类的成员变量和局部变量
成员变量可以在类的各个地方调用，局部变量只能在声明的方法内使用
访问控制修饰符 : default, public , protected, private
非访问控制修饰符 : final, abstract, static, synchronized
对于访问控制修饰符我们从单词的意思就可以直接了解这个，public就是公开的，对其他文件包括类都是开发的。private是私有属性，只能在自己的类文件使用。
语法点拨
大小写敏感：Java 是大小写敏感的，这就意味着标识符 Hello 与 hello 是不同的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记 Java 是大小写敏感的），文件名的后缀为 .java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的 Java 程序由 public static void main(String[] args) 方法开始执行。
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。关于 Java 标识符，有以下几点需要注意：
所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
合法标识符举例：age、$salary、_value、__1_value
非法标识符举例：123abc、-salary
基本数据类型
规律性的：
byte：
占用内存8位，max=2^7 -1，min=-2^7，占用int类型的四分之一
short：
占用内存16位，max=2^15 -1,min=-2^15，占用int类型的二分之一
规律说明后面依次的int，long类型都是这样的32,64，对应的运算都是减一。
我们有的时候在进行定义数据的时候，如果超过了就会导致储存的溢出，所以为了程序的健壮我们需要了解这些东西。
上机操作
public class study1{
// 全局常量，可以在本类的任何的地方使用
private static final int DTY=20*60*90;
public static void main(String[]args){
// 局部常量，只能在本代码块里面使用
final String a="hello java";
System.out.println("this is "+Short.MAX_VALUE);
String b ="hello world";
System.out.println(b);
System.out.println(DTY);
System.out.println(a);
}
}
我们发现了规律，在Java的程序里面，每一个变量都需要提前声明它的类型，如果是一个文本字符串需要String，如果是一个单字符需要char，注意这里的必须是单引号，整数就是int ，浮点数就是float等。这个程序里面有全局常量和局部的。我们看看运行效果
数据类型转换：
byte,short,char—> int —> long—> float —> double
变量与常量
常量
常量是预先定义好的，不可以在后面程序代码里面进行修改的固定值，定义方法一般是大写字母加下划线组成，首字母大写，会使用final关键字进行定义，也会使用static定义一个静态的常量。我们经常使用前者进行定义。
变量
其实变量我们用的更多，对于变量我们要了解一下几个方法
数据类型 变量名 = 数值
在方法之外的变量是需要static修饰不然就会出现问题
我们看看下面的这个代码
package com.company;
public class 变量与常量 {
private static int a=10;
private static String b="hello java!!!";
private static char c='k';
public static void main(String[]args){
int d;
String f;
f="加油！";d=30;
int e=a+d;
e++;
// 变量与常量 b = new 变量与常量();
System.out.println(e);
System.out.println(c);
System.out.println(b);
// int x=10;
// int j=++x;
// System.out.println(x);
}
}
注意这里不在b那里定义一个static这个修饰符，它就会报错，因为这个是方法之外的变量，需要我们修饰。
int a, b, c; // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22; // 声明并初始化 z
String s = "runoob"; // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x'; // 声明变量 x 的值是字符 'x'。
类变量：独立于方法之外的变量，用 static 修饰。
实例变量：独立于方法之外的变量，不过没有 static 修饰。
局部变量：类的方法中的变量。
变量可以先定义不用赋值
public class Variable{
static int allClicks=0; // 类变量
String str="hello world"; // 实例变量
public void method(){
int i =0; // 局部变量
}
}
局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
Java执行也是从main方法开始执行的额，所以才有了很多的类的基础知识
package com.company;
public class 对象 {
// 这里的age是一个局部变量，它的作用域有限制，所以我们要进行加工处理
public void pupAge(){
int age = 0;
age = age + 7;
System.out.println("小狗的年龄是: " + age);
}
//在主方法里面进行实现，所以就把上面的类实例化，这样就可以实现了，这个就是类的多次使用
public static void main(String[] args){
对象 test = new 对象();
test.pupAge();
}
}
实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
类变量
类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
运算符
我自己总结一部分比如一些常见的，比较简单的我这里就不枚举了。
递增运算和递减运算符
++a 的意思就是先进行运算，然后在把这个结果给原来的那个变量，当然现在这个变量也是一样的。
a++的意思就是先不运算，先返回一个值，然后把这个值给原来的变量，最后至于这个已经有的变量的值是不变的。
这样说可能有点晦涩难懂，我们直接看一些代码吧
public class Test {
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) );
}
}
我们只需要注意后面两个了，我这里详细的解释一下，首先d的值为25，进行了后++，那么就是先返回值，后运算，所以现在的打印结果是25，但是这个d的实际值发生了改变为26了，因为进行了运算。
之后我们进行前++，先运算，后返回值，那么就是26+1=27 所以打印的值为27。
现在应该明白了吧！
三元运算符
条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要是决定哪个值应该赋值给变量。
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 );
}
}
简单的说就是需要对前面的条件进行判断，如果为真，那么结果就是第一个值，为假就是第二个值。
如果后面只有一个值，那么就是为真就直接用之前的值（应该会有数值），如果为假就用后面给的那一个值。
对于Java来说它的运算符还有很多，我这里就不完全的介绍了。学到这里是不是有一种C语言的感觉，不错有些东西就和C语言差不多的。
每文一语
要想做好一件事，就不要去过于的规划太多，有的时候直接出击可能来的更准确！