注释

文档注释

以/*开头，/结尾

  1. /**
  2.  * @author danta
  3.  * @version jdk1.8.0
  4.  */
  5. public class Instance {
  6.     /**
  7.      * 请求输入两个参数范围以内正数的和
  8.      * @param n 接收的第一个参数，范围起点
  9.      * @param m 接收的第二个参数，范围终点
  10.      * @return 两个参数范围内整数的和
  11.      */
  12.     public int add(int n,int m) {
  13.         int sum=0;
  14.         for (int i=n;i<=m;i++){
  15.             sum=sum+i;
  16.         }
  17.         return sum;
  18.     }
  19. }

单行/多行注释

单行：以//开始
多行：以/开始，/结束

  1. public class Instance {
  2.     public int add(int n,int m) {
  3.         /*
  4.         *多行注释
  5.         * 第二行
  6.          */
  7.         int sum=0;  //定义一个int类型
  8.         for (int i=n;i<=m;i++){
  9.             sum=sum+i;
  10.         }
  11.         return sum;
  12.     }
  13. }

常量

字面常量类型

常量：程序执行时，其值不可用发生改变
*java中的字面常量：
字符串常量、整数常量、小数常量、布尔常量、空常量、字符常量

  1. package com.company;
  2. /**
  3.  * @author danta
  4.  * @version jdk1.8.0
  5.  */
  6. public class Main {
  8.     public static void main(String[] args) {
  9.         System.out.println("123QWE"+"----字符串常量"); //字符常量
  10.         System.out.println(416);   //整数常量
  11.         System.out.println(4.16);   //小数常量
  12.         System.out.println(true);   //布尔常量
  13.         System.out.println();      //空常量
  14.         System.out.println('A');    //字符常量
  15.     }
  16. }

定义常量

常量类型：
静态常量、成员常量、局部常量

  1. package com.company;
  2. /**
  3.  * @author danta
  4.  * @version jdk1.8.0
  5.  */
  6. public class Main {
  7.     //静态常量
  8.     public static final double PI=3.14;
  9.     //成员常量
  10.     final int Y=10;
  11.     public static void main(String[] args) {
  12.         //局部常量
  13.         final double X=4.16;   
  14.         System.out.println(X);
  15.         System.out.println(PI);
  16.     }
  17. }

注：static方法只能够调用static修饰的方法或者变量，所以上诉代码中main内不能调用成员常量。

变量

定义变量

  1. package com.company;
  3. /**
  4.  * @author danta
  5.  * @version jdk1.8.0
  6.  */
  7. public class Main {
  8.     public static void main(String[] args) {
  9.         /*
  10.         整数型
  11.          */
  12.         byte a=1;   //一个字节
  13.         short b=1988;  //两个字节
  14.         int c=416;  //四个字节   整数默认的是int类型
  15.         long d=416000000000000000L;  //八个字节
  16.         /*
  17.         小数型
  18.          */
  19.         float e=14.1F;  // 浮点型，默认为double类型
  20.         double f=4.16;   // double类型
  21.         /*
  22.         字符型
  23.          */
  24.         char g='A';    
  25.         /*
  26.         布尔型
  27.          */
  28.         boolean h=false;   
  29.         /*
  30.         字符串型
  31.          */
  32.         String i="0416加油";
  33.         System.out.println(a);
  34.         System.out.println(b);
  35.         System.out.println(c);
  36.         System.out.println(d);
  37.         System.out.println(e);
  38.         System.out.println(f);
  39.         System.out.println(g);
  40.         System.out.println(h);
  41.         System.out.println(i);
  42.     }
  43. }

定义long类型的整数在值过大时要加L，整数默认的是 int 类型； 浮点型没有指定float，也是默认doblue类型

数组

  1. import java.util.Arrays;
  3. public class ArrayDemo {
  4.     public static void main(String[] args) {
  5.         //1、数组的声明
  6.         int[] arr;
  7.         //2、数组的初始化
  8.         int[] arr1={1,2,3};
  9.         //创建一个空数组 长度为4 默认为0 0 0 0
  10.         int[] arr2=new int[4];
  11.         //3、数组的访问
  12.         int x=arr1[2];    //取出下标为2的元素
  13.         //4、长度
  14.         int[] arr3={1,3,2,5};
  15.         int count=arr3.length;
  16.         System.out.println(count);
  17.         //5、元素的初始化操作
  18.         int[] arr4 =new int[5];
  19.         for(int i=0;i<arr4.length;i++){
  20.             arr4[i]=i+1;
  21.         }
  22.         //6、打印数组    import java.util.Arrays;
  23.         System.out.println(Arrays.toString(arr4));
  24.         //7、数组的遍历---增强型for循环   for(int bb:aa)   只能取值，不能存值；
  25.         int[] a=new int[5]; 
  26.         for (int value:a){
  27.             System.out.println(value);
  28.             }
  29.     }
  30. }

随机函数

  1. import java.util.Random;
  3. public class RandomDemo {
  4.     public static void main(String[] args) {
  5.         //创建一个random对象 
  6.         Random ran =new Random();
  7.         //从0-9取出一个数   n   0~n-1   
  8.         int x=ran.nextInt(10);
  9.         System.out.println(x);
  10.     }
  11. }

字符串操作

  1. import java.util.Arrays;
  3. public class StringDemo {
  4.     public static void main(String[] args) {
  5.         String str="12345678987654321";
  6.         //从字符串中查找某字符串 第一次出现的位置 返回的是下标 找不到返回-1
  7.         int a=str.indexOf("2");
  8.         //从字符串中查找某字符串 最后一次出现的位置
  9.         int b=str.lastIndexOf("2");
  10.         System.out.println(a+"-----"+b);
  11.         //截取字符串str  按下标开始截取 只有开始下标
  12.         String s1=str.substring(2);
  13.         //截取字符串str  按下标开始截取 开始下标到结束下标  取头不取尾
  14.         String s2=str.substring(2,8);
  15.         System.out.println(s1+"------"+s2);
  16.         //判断str是否以某字符串开始
  17.         boolean b1=str.startsWith("as");
  18.         //判断str是否以某字符串结束
  19.         boolean b2=str.endsWith("1");
  20.         System.out.println(b1+"-------"+b2);
  21.         //取出字符串两端的空白
  22.         String str1=" 1 2 32  4 43 \n";
  23.         String str11=str1.trim();
  24.         System.out.println(str11);
  25.         //判断字符串是否相等
  26.         System.out.println(str.equals("12345678987654321"));
  27.         //根据字符去拆分str，拆分结果以数组返回
  28.         String str2="asfsfsfdytewafsfzgd";
  29.         String[] strArr=str2.split("s");
  30.         System.out.println(Arrays.toString(strArr));
  31.     }
  32. }

类与对象

方法： [修饰符] 返回类型 方法名(参数类型 参数变量，参数类型2 变量2){方法体}

  • 修饰符可以是0~n个，但是要保证正确使用
  • 方法的参数可以是0~n个
  • 方法的参数是局部变量
  • 如果方法有返回值（返回类型不是void），那么该方法就必须有return语句，用来返回和返回类型相兼容的数据，此时return后面必须加数据
  • 如果方法无返回值（返回类型是void），那么该方法中科院有return语句（也可以没有），如果有return语句用来直接跳出方法体，此时return后面一定不能加数据
  • 方法中不能嵌套方法
  • 实参：实际传入方法中的参数，相当于给变量初始化
  • 形参：形式参数，是方法临时定义的参数，相当于只声明了变量

默认构造器

  • 每个类都有构造方法
  • 如果类没有定义构造方法，java会自动添加默认构造方法
  • 默认构造方法是共有空实现的
  • 如果定义了构造方法，就不再提供默认构造器了，如：public Student(){}

this

  • 代表当前对象本身，是当前对象的引用，就像交谈中：代词“我”，代表说话人本身
  • 用法
    • 引用当前对象的成员：属性或方法
    • 如：public Student(String name,int age){
      1.       - this.name=name;
      2.       - this.age=age;}

Student类

  1. public class Student {
  2.     //成员变量
  3.     //成员变量可以在任意类中访问
  4.     //成员变量会有默认值
  5.     String name;
  6.     String id;
  7.     int age;
  8.     //方法 没有返回值用void声明
  9.     public void study(String course){
  10.         System.out.println("I love study"+course);
  11.         return;
  12.     }
  13.     public int add(int a,int b){
  14.         int x=a+b;
  15.         return x;
  16.     }
  17. }

创建对象

  1. public class TestStudent {
  2.     public static void main(String[] args) {
  3.         //创建了一个学生对象
  4.         Student s1=new Student();
  5.         s1.age=18;
  6.         s1.id="123";
  7.         s1.name="乎乎";
  8.         s1.study("java");
  9.         int count_res=s1.add(1,3);
  10.         System.out.println(count_res);
  11.     }
  12. }