05 java基础

 


 

01注释

//表示单行注释

/*

*/表示多行注释


 

02数据类型讲解

标识符注意点

  1. 所有的标识符都应该以字母(A-Z或者a-z),美元符($)、或者下划线()开始,首字符之后可以是字母(A-Z或者a-z),美元符($)、下划线()或数字的任何字符组合

  2. 不能使用关键字作为变量名或方法名。

  3. 标识符是大小写敏感的

  4. 合法标识符举例:age,$salary,_value,_1_value

  5. 非法标识符举例:123abc, -salary, #abc

  6. 可以使用中文命名,但是一般不建议这样去使用,也不建议使用拼音,很Low


03数据类型

强类型语言:要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用

弱类型语言:反过来 Java的数据类型分为两大类

基本类型(primitive type):整数类型(byte,short,int,long),浮点(float,long),字符(char),布尔(boolean) 引用类型(reference type):类,接口,数组

public class Demo02 {
   //psvm
   public static void main(String[] args) {
       //八大基本数据类型

       //整数4类型
       int num1 = 10;
       byte num2 = 20;
       short num3 = 30;
       long num4 = 30L;  //long类型后加大写L

       //小数2类型
       float num5 = 50.1F;  //float类型后需要加大写F
       double num6 = 3.1447397197;

       //字符
       char name = 'A';

       //字符串, String不是关键字,类
       //String namea = '启超';

       //boolean值
       boolean flag = true;
       // boolean flag = false;

       System.out.println(num1);
       /*
       ...
       */
  }
}

 

04 数据类型拓展

public class Demo02 {
   //psvm
   public static void main(String[] args) {
       //整数拓展: 进制 二进制0b   十进制 八进制0 十六进制0x
       int i1 = 10;
       int i2 = 010;  //八进制
       int i3 = 0x10;   //十六进制   0~9, A~F
       System.out.println(i1);
       System.out.println(i2);
       System.out.println(i3);
       System.out.println("=====================");

       //浮点数拓展
       // float 有限的 离散的   舍入误差 大约 接近但不等于
       // double
       // 最好不要用浮点数进行比较
       float f = 0.1f;  //0.1
       double d = 1.0/10; //0.1
       System.out.println(f==d);  //false
       System.out.println(f);
       System.out.println(d);

       float d1 = 212121212121212f;
       float d2 = d1 + 1;
       System.out.println(d1==d2);   //True
       System.out.println("=====================");
       //字符扩展
       char c1 = 'a';
       char c2 = '中';

       System.out.println(c1);
       System.out.println((int)c1);  //强制换行
       System.out.println(c2);
       System.out.println((int)c2);//强制换行
       //所有的字符本质还是数字
       //编码 Unicode 查表:(97 = a 65 = A) 2字节   65536 Excel 2**16 = 65536
       //U0000 UFFFF
       char c3 = '\u0061';
       System.out.println(c3); //a

       //转义字符
       // \t 制表符
       // \n 换行
       //。。。
       System.out.println("Hello\nWorld");


       System.out.println("=====================");
       String sa = new String("hello world");
       String sb = new String("hello world");
       System.out.println(sa==sb);

       String sc = "hello world";
       String sd = "hello world";
       System.out.println(sc==sd);
       //对象
       //从内存分析
       //布尔值扩展
       boolean flag = true;
       if (flag == true){}    //新手
       if (flag){}     //老手 默认true
       // less is more 代码要精简易读
}

 

05类型转换

public class Demo5 {
   public static void main(String[] args) {
       int i = 128;
       byte b = (byte)i;  //内存溢出

       //强制转换     (类型)变量名 高--低
       //自动转换               低--高

       System.out.println(i);
       System.out.println(b);
       System.out.println("=================");
       int a = 128;
       double c = i;  //内存溢出
       System.out.println(a);
       System.out.println(c);

       /*
       注意点:
       1.不能对布尔类型转换
       2.不能把对象类型转换为不相干的类型
       3.再把高容量转换到低容量的时候
       4.转换的时候可能出现内存溢出,或者精度问题
        */
       System.out.println("============");
       System.out.println((int)23.7);  //23
       System.out.println((int)-45.89f);  //-45

       System.out.println("===========");
       char m = 'a';
       int d = m + 1;
       System.out.println(d);
       System.out.println((char) d);
  }
}
public class Demo6 {
   public static void main(String[] args) {
       //操作比较大的数的时候注意溢出问题
       //JDK7新特性, 数字之间可以用下划线分割
       int money = 10_0000_0000;
       int years = 20;
       int total1 = money*years;  //计算的时候溢出
       long total2 = money*years;  //默认int,转换之前已经出现问题了
       long total3 = money*((long)years);  //先把一个数转换为long

       System.out.println(total1);
       System.out.println(total2);
       System.out.println(total3);
  }
}

 

06变量,常量,作用域

public class Demo7 {
   public static void main(String[] args) {
       //int a b c
       //int a = 1,b = 2,c = 3;
       String x = "X";
       double pi = 3.14;
  }
}

变量

public class Demo08 {

   //类变量 static
   static double salary = "2500"

   //属性;变量

   //实例变量:从属于对象;如果不自行初始化,这个类型的默认值 0,0.0
   //布尔值,默认false
   //除了基本类型,其余的默认值都是null
   String name;
   int age;

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


       //变量类型 变量名字 = new Demo08();
       Demo08 demo08 = new Demo08();
       System.out.println(demo08.age);
       System.out.println(demo08.name);

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

   // 其他方法
   public void add(){

  }
}

变量的命名规范

  1. 所有变量、方法、类名:见名知意

  2. 类成员变量:首字母小写和驼峰原则:monthSalary除了第一个单词以外,后面的单词首字大写lastname ,lastName

  3. 局部变量:首字母小写和驼峰原则

  4. 常量:大写字母和下划线:MAX_VALUE

  5. 类名:首字母大写和驼峰原则:Man,GoodMan

  6. 方法名:首字母小写和驼峰原则:run(),runRun()

 

常量

public class Demo09 {
   //修饰符,不存在先后顺序
   static final double pi = 3.14;

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

}

 

07运算符-------优先级用”()“

基本运算符

package operator;

public class Demo01 {
   public static void main(String[] args) {
       //二元运算符
       //ctrl+D 复制当前行到下一行
       int a = 10;
       int b = 20;
       int c = 25;
       int d = 25;

       System.out.println(a+b);
       System.out.println(a-b);
       System.out.println(a*b);
       System.out.println(a/b);  //0.5四舍五入往左取值了
       System.out.println(a/(double)b);  //强转
  }
}
package operator;

public class Demo02 {
   public static void main(String[] args) {
       long a = 123123123123123123L;
       int b = 123;
       short c = 10;
       byte d = 8;

       System.out.println(a+b+c+d);//long
       System.out.println(b+c+d);//int
       System.out.println(c+d);//int
  }
}
package operator;

public class Demo03 {
   public static void main(String[] args) {
       //关系运算符返回的结果: 正确,错误   布尔值
       int a = 10;
       int b = 20;
       int c = 21;
       System.out.println(a>b);
       System.out.println(a<b);
       System.out.println(a==b);
       System.out.println(a!=b);
       System.out.println(c%a);  //取余运算,又叫模运算
  }


}

 

自增自减运算符 ,初识Math类

package operator;

public class Demo4 {
   public static void main(String[] args) {
       //++ -- 自增自减 一元运算符
       int a = 3;
       int b = a++;  //先给b赋值,之后在自更新
       // a = a + 1
       System.out.println(a);
       // a = a + 1
       int c = ++a;// 执行代码前先自更,再给b赋值

       System.out.println(a);
       System.out.println(b);
       System.out.println(c);

       //幂运算 2^3   很多运算都是用工具来操作例如‘Math.’
       double pow = Math.pow(2,3);
       System.out.println(pow);
  }
}

逻辑运算符,位运算符

package operator;

//逻辑运算符
public class Demo05 {
   public static void main(String[] args) {
       // 与and 或or 非 取反
       boolean a = true;
       boolean b = false;

       System.out.println("a&&b:"+(a&&b));
       System.out.println("a||b:"+(a||b));
       System.out.println("!(a&&b):"+!(a&&b));

       //短路运算   c<4 false, 后边的c++<4就不再计算了
       int c = 5;
       boolean d = (c<4)&&(c++<4);
       System.out.println(d);
       System.out.println(c);

  }
}
package operator;

public class Demo06 {
   public static void main(String[] args) {
       /*
       A = 0011 1100
       B = 0000 1101
       -----------------------------
       A&B = 00001100 ALL 1 = 1
       A|B = 0011 1101   ANY 1 = 1
       A^B = 0011 0001   DEFRENT = 1
       -B = 1100 1110   EQUAL = 1

       2*8 = 16 2*2*2*2
       << *2
       >> /2

       0000 0000 0
       0000 0001 1
       0000 0010 2
       0000 0011 3
       0000 0100 4
       0000 1000 8
       0001 0000 16
        */
       System.out.println(2<<3);
  }
}
package operator;

public class Demo07 {
   public static void main(String[] args) {
       int a = 10;
       int b = 20;

       a+=b; // a = a+b
       a-=b; //a = a - b
       System.out.println(a);

       //字符串连接符   + ,string
       System.out.println(""+a+b);//字符串在前面,后边的拼接
       System.out.println(a+b+"");//字符串在后边,前边的依旧运算

  }
}
package operator;

public class Demo08 {
   public static void main(String[] args) {
       // x ? y : z
       // if x == true, 则 结果为y,否则为z

       int score = 50;
       String type = score < 60?  "不及格":"及格";
       // if
       System.out.println(type);

  }
}

包机制

定义包: package 名

一般利用公司域名倒置作为包名; eg: com.cao.xxx

导入包: import 名

import 名.* //导入这个包下所有的类

 

看一本书《阿里巴巴开发手册》

 


 

08 JavaDoc

  1. javadoc命令是用来生成自己API文档的

  2. 参数信息 @author 作者名 @version版本号 @since指明需要最早使用的jdk版本 @param参数名 @return返回值情况 @throws异常抛出情况

package base;
//给类加注释
/*
* @author Kuangshen
* @version 1.0
* @since 1.8
*/
public class Doc {
   String name;  //这是属性

   //给方法加注释

   /**
    * @author Kuangshen
    * @param name
    * @return
    * @throws Exception
    */
   public  String test(String name) throws  Exception{    //这是个方法
       return name;
  }
   //我是通过命令行生成的javadoc文档   javadoc 参数 java文件
   //作业: 学会查找使用IDEA生成JavaDoc文档:   百度一搜特别多
}

 

posted @ 2022-02-27 12:32  CHPang  阅读(70)  评论(0)    收藏  举报