第一个java程序及基本语法

/*
 * java的基本语法：
 * 1.类名必须和文件名一致
 * 2.public：访问修饰符
 * 3.class：定义类的关键字
 * 4.类名：首字母大写，不要使用拼音或者中文，驼峰式命名法，每个单词的首字母大写
 * 5.main方法是Java程序的入口，需要执行的代码必须放到main方法里面，后期学了JavaEE用的不是太多了
 * 6.Java语言严格区分大小写 int a，int A；
 * 7.Java方法由一条条语句构成，每个语句以“；”结束
 * 8.大括号都是成对出现的，缺一不可
 * 9.一个Java文件里面可以定义多个类，但是只能有一个类名的访问修饰权限为public
 * 
 * 
 * 什么是关键字？
 * Java给我们定义了一些特殊单词，每个关键字都有自己独有的功能
 * 1.全是小写
 * 2.关键字不能当做普通的标识符
 * 
 * 什么是标识符？
 * 自定义的类，方法名，包名，变量名，接口名......这些统称标识符
 * 1.字母，数字，下划线$
 * 2.不能以数字开头
 * 3.不能是关键字，或者包含特殊字符
 */

public class HelloWorld {
      public static void main(String[] args){
          System.out.println("HelloWorld");
      }
}

 

//新建一个Demo1类，常量的例子

public class Demo1 {

    public static void main(String[] args) {
/*
 * 什么是常量？程序运行期间，固定的值是不可以改变的
 */
        //final关键字表示不可变
        final int A=10;
        //整数
        System.out.println(100);
        //字符串
        System.out.println("我爱学习");
        //小数
        System.out.println(3.14);
    }

}

 

//新建一个Demo2的类，变量的例子

/*
 * 1.什么是变量？
 * 在内容中的一块区域，变量的值可以在某一个范围内发生改变
 * 2.怎么定义变量？
 * 变量类型  变量名；int num;
 * 变量类型  变量名=对应的变量值；int num=10;
 * 3.变量的类型有哪些呢？
 * 基本数据类型
 * 整数 byte short int long 常用的是int
 * 小数 double float 常用的是double
 * 布尔 boolean 常用在逻辑运算
 * 字符 char
 * 
 * 引用数据类型：数组  Java定义的类 自己定义的类 接口......
 * 
 * 4.变量的分类
 * （1）成员变量：定义在类的内部，方法之外，可以在当前类的内部使用
 * （2）局部变量：定义在方法内部，只能在当前方法内部使用
 */

//新建一个类Demo2，成员变量和局部变量的区别

public class Demo2 {
    //成员变量
    static  int num=10;//在静态方法里面只能调用静态变量或者静态方法
    public static void main(String[] args) {
        //局部变量
        int num1=20;
        System.out.println("num:"+num);
        System.out.println("num1:"+num1);
    }
public void show(){
    System.out.println("num:"+num);

//这句是有错误的，因为获取不到在main方法中声明的局部变量num1
    System.out.println("num1:"+num1);
}
}

//新建一个类Demo3，八种基本类型的创建格式，不同类型之间的转换方法

public class Demo3 {

    public static void main(String[] args) {
        /*
         * java的基本类型
         * 八种：byte short int long float double char boolean
         * js是弱类型语言  Java是强类型语言
         */
        
        //1.byte的范围 -128一127
        //b=128;右边的赋值数字不能超过左边数据类型的范围
        byte b=120;
        System.out.println("B:"+b);
        //如果要定义成long类型，后面必须加上大写的L或者小写的l
        long l=1000L;
        System.out.println("L:"+l);
        
        //2.小数
        double d= 10;
        System.out.println("d:"+d);
        //float值必须加上大写的F或者小写f
        float f=12F;
        System.out.println("f:"+f);
        
        //3.字符型，字符型不能为空，字符串可以为空，字符用单引号，字符串用双引号
        char c='a';
        System.out.println("c:"+c);
        
        //4.布尔类型 只有两个值 true false
        boolean b1=true;
        System.out.println("b1:"+b1);
        
        /*
         * 类型转换
         * 1.自动类型转换：把小的放到大的里面
         * 2.强制类型转换：把大的放到小的里面
         * 3.把字符串类型转换成其他数据类型（使用对应包装类的parsexxx（）方法）
         */
        System.out.println("==============");
        short s=10;
        //把小的（short类型）转换成大的（int类型），可以自动类型转换
        int num =s;
        System.out.println("num:"+num);
        
        int num1=20;
        //把大的数据类型转换成小的数据类型，需要强制类型转换
        //需要转成什么类型，在变量前面加上该类型就可以了
        short s1=(short)num1;
        System.out.println("s1:"+s1);
        
        System.out.println("==========================");
        //把字符串转成int类型,转换有前提，字符串的值不能包含中文
        String str="123";
        //每一个基本数据类型都有自己对应的包装类，每个包装类里面都封装了对应的转换方法
        //Integer是int类型的包装类
        int num2=Integer.parseInt(str);//把字符串转成了int
        System.out.println("num2:"+num2);
        
        //把字符串转成double
        String str1="456";
        double dob=Double.parseDouble(str1);
        System.out.println("dob:"+dob);
        
        //把int类型转成字符串
        int num3=110;
        String str2=num3+"";
        System.out.println("str2:"+str2);
        
        //第二种方式
        int num4=120;
        //转成什么类型，那么就去String类里面找方法
        String str3=String.valueOf(num4);
        System.out.println("str3:"+str3);
        
        //转义\n表示换行
    System.out.println("我是\n中国人");
        
    }

}

//Demo3运行结果

 

//创建一个类Demo4，表示算术运算，自加自减符号前后的异同/*
 * 算术运算符
 * +
 * -
 * *
 * /
 *%
 *
 *1.自增运算++ 在原有的基础上，累加1
 *2.自减运算 --  在原有的基础上，累减1
 *
 *使用格式：
 * 可以在变量前面使用++  ++num
 * 可以在变量后面使用++  num++
 * 
 * 前后有啥区别？
 * 1.如果单独使用的话，没有任何区别
 * 2.混合使用
 * (1).如果是后++，先使用变量的值，然后在+1，先用后加
 * (2),如果是前++，变量的值会立马+1，如果拿着累加的值进行使用，先加后用
 */

public class Demo4 {

    public static void main(String[] args) {
                //加
                //作用在数字上面,求和
                int num=10;
                int num1=20;
                System.out.println(num+num1);
                
                //作用在字符上面，不是求和，而是两个字符串拼接
                String str="尼古拉斯赵四";
                int num2=20;
                System.out.println(str+num2);
                
                System.out.println("==================");
                int number=10;
                ++number;//单独使用
                System.out.println(number);
                
                int number1=10;
                number1++;//单独使用
                System.out.println(number1);//11
                
                System.out.println("====================");
                int a=10;
                System.out.println(++a);//11
                
                int b=10;
                System.out.println(b++);//10
                
                int d=10;
                int e=10;
                int f=(d++)+(++d)+(d--)+(--e)+(e++)+(++e);
                      //10+12+12+9+9+11
                System.out.println(f);
                
                int j=12;
                int h=16;
                int sum=(--j)+(h--)+(j++)+(++h)+(j--)+(++j);
                      // 11+16+11+16+12+12
                System.out.println(sum);

            

    }

}

//Demo4运行结果

 

新建一个类Demo5，运算操作简写/**
 *  赋值运算符:就是把右边的值赋值给左边的变量
 *  = ：不是相等的意思，赋值
 *  += : a=a+b;可以简写成a+=b,
 *  -=
 *  *=
 *  /=
 *  %=
 *
 */

public class Demo5 {

    public static void main(String[] args) {
        int a=10;
        int b=10;
//        a=a+b; 可以简写，功能相同
        a+=b;
        System.out.println(a);

    }

}

//Demo5运行结果

 

 

创建一个类Demo6，基本数据类型的比较/**
 * 比较运算符：比较两个变量值  只是针对于基本数据类型进行比较
 * 比较后只能是Boolean，要么为true要么为false
 * == 比较两个值是否相等
 * >
 * <
 * !=
 * >=
 * <=
 *
 */

public class Demo6 {

    public static void main(String[] args) {
    int a=20;
    int b=30;
    System.out.println(a==b);//false

    }

}

//Demo6运行结果

 

类Demo7，逻辑运算符/**
 * 逻辑运算符
 * &(并且)：所有的条件都为true，返回true，如果其中有一个为false，就为false
 * |(或者)：只要有一个为true，就返回true，如果都为false，返回false
 * ^(异)：相同为false，不同为true
 * ！(非)：本来是false改成true
 * 
 * 逻辑运算符 &和|可以双写
 * 单写和双写有什么区别呢？
 * 1.短路与：如果左侧已经可以判断最终结果了，那么后面的判断将不会再被执行
 * 以后开发使用短路与，因为它的开发执行效率高
 *
 */

public class Demo7 {

    public static void main(String[] args) {
        boolean a=true;
        boolean b=false;
        System.out.println(a&b);//false
        System.out.println(4>3|7<2);//true
        System.out.println(true^true);//false
        System.out.println(!true);//false
        
        System.out.println("==========区别==============");
        int num=10;
        System.out.println(3>4 & ++num>5);
        System.out.println(num);//11
        
        int num1=10;
        System.out.println(3>4 && ++num1>5);
        System.out.println(num1);//10
        
        System.out.println("==============");
        int num2=10;
        System.out.println(4>3 | ++num2<10);
        System.out.println(num2);//11
        
        int num3=10;
        System.out.println(4>3 || ++num3<10);
        System.out.println(num3);//10
        

    }

}

Demo7的结果

 

类Demo8，三元运算，两个数的值的交换

public class Demo8 {

    public static void main(String[] args) {
        /**
         * 三元运算符：
         * 条件表达式？表达式1：表达式2
         * 如果条件表达式为true，执行表达式1
         * 如果条件表达式为false，执行表达式2
         */
        
        //定义两个整数，判断a是否大于b，如果大于b,输出a大，相反输出b大
        int a=100;
        int b=200;
        //创建一个String的容器来存放输出的结果信息
        String result= (a>b)?"a大":"b大";
        System.out.println(result);
        
        //实现两个变量值的互换
        int m=6;
        int n=5;
        int t;
        t=m;
        m=n;
        n=t;
        System.out.println("m:"+m);
        System.out.println("n:"+n);
        
    }

}

Demo8的运行结果