标签：Java String int 基础 System println public out

注释

种类

单行注释 //内容
多行注释 /* 内容*/
文档注释 /* * 内容*/

写注释是很好的习惯！！！

标识符注意点

以字母/美元/_为开头
标识符是大小写敏感的，所以一定要注意
类名no中文，标识符no拼音

数据类型

强类型语言：变量的使用要严格符合规定，所有变量必须先定义才能使用

基本类型：
1. 整数类型：byte,short,int,long
2. 浮点类型：float,double
3. 字符类型:char
4. Boolean类型：true,alse
引用类型：除了基本类型其他都是引用

数据类型拓展

数据类型及拓展，见下：

import com.sun.org.apache.xpath.internal.objects.XString;

public class HelloWorld {
    public static void main(String[] args) {
        //整数
        int num1 =10;//最常用
        byte num2=5;
        short num3=30;
        long num4=10000000L;//long类型很特殊，在尾巴加个L表示区分一下
        
        //小数：浮点数
        float num5 = 50.1F;//float类型在尾巴加F，要不然会报错
        double num6=3.141592738388333;
        
        //字符
        char name='a'; //单个字符，用'，不是双引号哦
        
        //字符串,String不是关键词，是一个类
        String namea="aaaaa";//字符串用"
        
        //布尔值Boolean，代表是非
        boolean flag=true;
        //boolean flag=flase;
        
        //整数拓展：进制 二进制0b 八进制0 十进制 十六进制0x
        int i=10;
        int i2=010;//八进制 用0、1、2、3、4、5、6、7表示
        int i3=0x10;//十六进制，用0、1、2、3、4、5、6、7、8、9、A=10、B=11、C=12、D=13、E=14、F=15表示
        System.out.println(i);//10
        System.out.println(i2);//8=1*8
        System.out.println(i3);//16=1*16
        //是从n进制变为十进制，从右往左，数字乘以n的0、1、2、、指数
        
        //浮点数拓展
        float f=0.1f;
        double d=0.1;
        System.out.println(f==d);//输出false，但明显f等于d
        float f1=222222222222222f;
        float f2=f1+1;
        System.out.println(f1==f2);//输出true，但明显不相等
        //因为float是有限的，离散的，有舍入误差，接近但不等于，因此最好避免使用浮点数进行比较
        //银行的钱业务，使用数学工具类：BigDecimal
        
        //字符拓展
        char c1='a';
        char c2='中';
        System.out.println(c1);//a
        System.out.println((int)c1);//强制转换：97
        System.out.println(c2);//中
        System.out.println((int)c2);//强制转换成整数：20013
        //说明所有的字符本质还是数字
        
        //转义字符
        // \t 制表符
        // \n 转行符

        String sa=new String(original:"hello,world");
        String sb=new String(original:"hello,world");
        System.out.println(sa==sb);//false
        
        String sc="hello,world";
        String sd="hello,world";
        System.out.println(sc==sd);//ture
        //因为对象 从内存方面分析（以后会学）
        
        //布尔值拓展
        boolean flag1=true;
        if (flag1==true){}//新手程序员
        if (flag1){}//老手程序员
        //这两个是一致的，代码要精简易读
        
    }
}

类型转换

因为Java是强类型语言，所以有些运算需要类型转换。在运算中，不同类型的数据先转化为同一类型，再计算

从低到高：

byte，short，char ——>int——>long——>float——>double

强制转换：（类型）变量名，为高到低
自动转换：从低到高，不用括号

注意事项：
1. 不能对布尔值进行转换
2. 不能把对象转换为不相干的类型
3. 注意是从高到低还是从低到高
4. 转换时可能出现内存溢出或精度问题

public class demo {
    public static void main(String[] args) {
        int i=128;
        byte b=(byte) i;//加了括号的这种，是强制转换
        System.out.println(i);//128
        System.out.println(b);//-128
        //因为byte小，内存溢出了

        int i2=128;
        double d=i2;
        System.out.println(i2);//128
        System.out.println(d);//128.0
        //从高到低，自动转换，不用括号

        System.out.println((int)23.7);//23
        System.out.println((int)-45.88f);//-45
        //出现精度问题

        int m=10_0000_0000;//数字之间可以用下划线分割，好看
        int y=20;
        int total=m*y;
        System.out.println(total);//-1474836480,说明溢出了
        long t2=m*((long)y);//把其中一个数变成long，不能直接把total变成long
        System.out.println(t2);
    }
}

变量

可以变化的量，是程序中最基础的存储单元，要素包括变量名、变量类型、作用域。

public class demo2 {
    public static void main(String[] args) {
        int a=1;
        int b=2;
        int c=3;//最好分开定义，不要一起
        String name="qqj";
        char x='x';
        double pi=3.14;
    }
}

注意事项

每个变量都有类型，可以是基本类型，引用类型
变量名必须是合法的标识符
变量声明是一条完整的语句，以；结束

变量作用域

类变量
实例变量
局部变量

public class demo2 {
    //实例变量：在外面,如果不自行初始化，就会输出默认值：0（整型）、0.0（浮点型）、false（布尔值）、null（除了基本类型，其余都是）
    String name;
    int age;

    //类变量：也在外面
    static double salary=2500;

    public static void main(String[] args) {
        //局部变量：必须声明和初始化值,且在里面
        int i=10;
        System.out.println(i);

        //变量类型：变量名字=new demo2()
        //在外面设置实例变量，然后在里面设置好变量类型,最后输出
        demo2 demo2=new demo2();
        System.out.println(demo2.age);//0
        System.out.println(demo2.name);//num(string不属于基本类型)

        //输出类变量
        System.out.println(salary);
    }
}

变量命名规范

类成员变量：首字母小写和驼峰原则
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线
类名：首字母大写和驼峰原则
方法名：首字母小写和驼峰原则

不要懒的大写！为了规范！！！！

常量

final 常量名=值；

常量名一般使用大写字符

public class demo2 {
    //如果在外面，是：static final double PI=3.14;
    public static void main(String[] args) {
       final double PI=3.14;//在里面就直接final
        System.out.println(PI);
    }
}

基本运算符

优先级：（）最大

算术运算符：+、-、*、/、%（余）、++(自增)、--(自减)
赋值运算符：=（是赋值！！）
关系运算符：<,>,<=,>=,==(表示相等，和物理类似)，！=（不等于），instance of
逻辑运算符：&&，||，！（与，或，非）
位运算符：&，|，^,~,>>,<<,>>> (了解)
条件运算符：？，：
扩展赋值运算符：+=，-=，*=，/=

6和7是偷懒用的

package operator;

public class Demo01 {
    public static void main(String[] args) {
        //二元运算符
        int a=10;//ctrl+d 复制当前行到下一行
        int b=20;
        System.out.println(a/b);//0,精度不高，所以转换成浮点型
        System.out.println(a/(double)b);//0.5

        long c=11111111111111L;
        int d=123;
        short e=10;
        byte f=8;
        System.out.println(c+d+e+f);//long，在多个操作中，有一个为long，则最终返回为long类型
        System.out.println(d+e+f);//int，在多个操作中，只要没有long，就返回为int
        System.out.println(e+f);//int

        //关系运算符返回的只会是false,ture
        int g=10;
        int h=20;
        System.out.println(g<h);//t
        System.out.println(g>h);//f
        System.out.println(g==h);//f
        System.out.println(g!=h);//t

        //取余
        int i=21;
        System.out.println(i%a);//1

        //自增，自减，易错噢（c语言时学过），是一元运算符
        int w=3;
        int x=w++;//先把w赋值给x，再执行w+1
        //w=w+1;
        System.out.println(w);//4
        //w=w+1;
        int z=++w;//先执行w+1，再把w赋值给z
        System.out.println(w);//5
        System.out.println(x);//3
        System.out.println(z);//5

        //幂运算：借助工具(跟C语言一样)
        double pow=Math.pow(2,3);//2的3次方
        System.out.println(pow);

        //逻辑运算符（与 或 非）
        boolean j=true;
        boolean k=false;
        System.out.println("j&&k:"+(j&&k));//逻辑与运算，两个变量都为真，结果才为真
        //如果是k&&j，运行时先看到k，发现他是假的，就直接返回假，不再经过j（懒！）
        System.out.println("j||k:"+(j||k));//逻辑或运算，两个变量中其中一个为真，则结果为真
        System.out.println("!(j&&k):"+!(j&&k));//如果是真，则变为假，如果是假，则变为真

        //位运算（会有面试题）
        /*
        A=0011 1100
        B=0000 1101
        A&B=0000 1100(两个都是1，才是1)
        A|B=0011 1101(都是0，则为0，只要有一个1，就是1)
        A^B=0011 0001(相同为0，不同为1)
        ~B=1111 0010(取反，0变1，1变0)
         */
        /*面试题：2*8怎么样运算最快
        0 0000 0000
        1 0000 0001
        2 0000 0010
        3 0000 0011
        4 0000 0100
        8 0000 1000
        16 0001 0000
        说明往左移动一位，就把数*2（<<左移）
        往右移动一位，就把数/2（>>右移）
        则2*8为2*2*2*2，即2要乘以三个2，因此把2向左移动三位，可以快速得到结果
         */
        System.out.println(2 << 3);//16

        //扩展运算符
        int s=10;
        int v=20;
        s+=v;//s=s+v
        s-=v;//s=s-v
        System.out.println(s);

        //字符串连接符
        System.out.println(s+v);//30
        //对应面试题：
        System.out.println(""+s+v);//1020
        //在+两侧，若前面出现string类型，则把两侧连接起来
        System.out.println(s+v+"");//30
        //会先运算s+v，不会连接起来

        //三元运算符 是偷懒写法，以后会学if，但是项目常用，因为简洁。
        //x?y:z  如果x==true，则结果为y，否则则为z
        int score=80;
        String type=score<60?"不及格":"及格";
        System.out.println(type);//及格
    }
}

包机制

包的本质是文件夹

自己搞了两个包

一般利用公司域名倒置作为包名，例如百度网址：www.baidu.com

他的包名是com.baidu.www

优化一下自己的，可以更加明确

包语句的语法格式为：

package pkg1[.pkg2[pkg3...]];

为了能使用某一个包的成员，需要明确导入该包，使用import语句

import package1[.package2..].(classname|*)

javadoc

Javadoc命令是用来生成自己api文档的

参数信息：

@author作者

@version版本号

@since最早使用的jdk版本
@param参数名

@return返回值情况

@throws异常抛出情况

package com.wang.base;

/**
 * @author redstar
 * @version 1.0
 * @since 1.8
 */
//加在类上，就是类的注释
public class Doc {
    String name;//是属性

    /**
     * @author redstar
     * @param name
     * @return
     * @throws Exception
     */
    //加在方法上，就是方法的注释
    public String test(String name)throws Exception{
        return name;//是方法
    }
}

标签：Java,String,int,基础,System,println,public,out
From： https://www.cnblogs.com/redstar-190601/p/18678570

Java基础

注释

种类

标识符注意点

数据类型

数据类型拓展

类型转换

注意事项：

变量

注意事项

变量作用域

变量命名规范

常量

基本运算符

包机制

javadoc

相关文章

赞助商

阅读排行