黑马程序员20天速成Java知识点

 序章、Java开发环境的准备

1、窗口win+r常用指令

2、 用记事本编写第一个代码

     文档后缀必须是.java；并且所有的都要用英文输入

 使用win+r，对程序进行编译，如下是运行步骤

 

 3、配置环境变量

        右击此电脑点击属性，再点击高级系统设置，再点击环境变量，里面上下（用户变量和系统变量）进行新建JAVA_HOME如图，再点击FATH编辑，再新建【%JAVA_HOME%\bin】最后确认及设置完环境变量

配置完后 ，win+r里面进行Java和javac进行测试是否成功

一、进制转换

1、二进制介绍

1、二进制转十进制  

八进制、十六进制也是同理

二进制转为十进制要从右到左用二进制的每个数去乘以2的相应次方

2、十进制转二进制

3、 八进制与十六进制转化二进制

 

2、 计算机存储单元

二、JAVA基础语法

1、注释

单行注释：//一次只能注释一行；快捷键：ctrl+/
多行注释：/*  */可以注释多行；快捷键：ctrl+shift+/
文档注释：/**  */

2、字面量 

    数据在程序中的书写格式

格式要求：字符必须单引号围起来，有且仅能一个字符。 字符串必须用双引号围起来。

特殊值书写格式：true、false、null（空）、\n（相当于回车）、\t （退格相当于tab）

3、变量

变量是用来记住程序要处理的数据的。

public class java1 {
    public static void main(String[] args) {
        /*变量的定义格式：*/
        /* 数据类型   变量名称     =
         * 数字的数据类型有int（整型），double（小数）
         * ‘=’是赋值
         *  变量名称自己定义*/
        int age =18;
        System.out.println(age);//打印18
    }
}

注意事项 ：

1、变量要先声明才能使用

2、变量是什么类型，就应该用来装什么类型的数据，否则报错

public class java1 {
    public static void main(String[] args) {
            int age='十八岁'//此处报错
        System.out.println(age);//打印18
    }
}

3、变量是从定义开始到“}”截止的范围内有效；且同一个范围内，定义的多个变量，它们的名称不能一样。

public class java1 {
    public static void main(String[] args) {
      int b = 16;
        {
            int a = 18;
        }
        System.out.println(a);//不在一个范围内报错
        int b =20; //重复定义一个变量报错
    }
}

4、变量定义的时候可以不赋初始值；但在使用时，变量里必须有值，否则报错。 

4、常量 

        1、标识常量
           标识常量使用一个标识符来代替一个常数值，定义如下
                final 数据类型 常量名 = 值
                    如： final int a =0
                其中final是关键字，说明再后面定义的是常量，即不能被其他程序修改的量（最终量）
        2、直接常量
                直接出现在程序语句中的常量如，如3.14 333等
    }

5、标识符、关键字

关键字是java用了的，我们就不能用来为做为：类名、变量名，否则会报错！

关键字：1、由数字、字母、下划线(_)和美元符($)等组成

               2、不能以数字开头、不能用关键字做为名字、且是区分大小写的。

6、数据类型

1、数据类型分类

注意 ：

  1、随便写的整数字面量默认是int类型，变换long类型的话需要+L
                如：long a = 99999999999999999999;//此处会报错，因为超出了默认int的范围
                正确方法： long a = 99999999999999999999L；//转换成了long类型
            2、随便写的小数字面量默认是double类型，变换程folat类型需要+F
                如： float b = 123.22；//此处会报错，此处没有转换成float型
                正确：float b = 123.333F；//此处转换成了folat型
            3、注意点：当数字比较打的时候使用科学计数
                    1.23e13=123乘以10的11次方；0.1e-8=1*10的-9次方

引用数据类型：string

string name = "你好"//也就是字符串类型
    System.out.println(name);//打印你好

2、类型转换

1、自动类型转换

类型范围小的变量，可以直接赋值给类型范围大的变量

 byte a = 100;
        short b= a;
        int c = b;
        long   d =c;
        float e = d;
        double f =e;//以上均可以自动转换
        char p ='a';//字符类型也可以转化成int类型；打印‘a’对应的ACII值

2、 表达式的自动类型转换

在表达式中，小范围类型的变量，会自动转换成表达式中较大范围的类型，再参与运算

注意：表达式的最终结果类型由表达式中的最高类型决定。

           在表达式中，byte、short、char 是直接转换成int类型参与运算的。

  1、最终类型由表达式中的最高类型决定。
        byte a = 10;
        byte b = 20;
        long c = 30;
         long rs = a + b +c ;//此处的最高类型是long所以定义的结果是long类型
        System.out.println(rs);

        double rs2 = a+ b+ c + 1.0;//因为此处的最高类型是double所以定义double类型

        2、byte short char是直接转换成int类型参与运算的。
            byte i = 10;
            short  j = 30;
            short l = i+j;//此处会报错，因为运行计算直接转换成int类型进行计算的
        正确：int l =i + j;

3、强制类型转换 

默认情况下，大范围类型的变量直接赋值给小范围类型的变量会报错！

可以强行将类型范围大的变量、数据赋值给类型范围小的变量。

强制类型转换
        数据类型 变量 = (数据类型)变量、数据
                int a = 20;
       byte b = (byte) a;//快捷键 alt+enter
        注意：强制类型转换可能造成数据(丢失)溢出；
             浮点型强转成整型，直接丢掉小数部分，保留整数部分返回

 7、运算符

1、基本的算术运算符、+符号做连接符

+ 、-、 *、 /、 % 

注意：如果两个整数做除法，其结果一定是整数，因为最高类型是整数（如需变成小数*1.0或设置double）

 与字符串做+运算时会被当成连接符，其结果还是字符串。能算则算不能算则拼接

2、自增自减运算符

        ++ 、-- 只能操作变量，不能操作字面量的 ；

注意：++、--不单独使用时 放在变量的前面，先对变量进行+1、-1，再拿变量的值进行运算。 放在变量的后面，先拿变量的值进行运算，再对变量的值进行+1、-1

3、赋值运算符 

注意：赋值运算符隐含了强制类型转换 

4、关系运算符 

判断数据是否满足条件，最终会返回一个判断的结果，这个结果是布尔类型的值：true或者false。 

   int a =12;
        int b =20;
        //a>b不能直接这样进行关系运算，需要定义布尔类型 boolean
        boolean c= a > b;//定义一个新的变量来接受他俩的关系运算，定义的变量需要是布尔类型的
        //或者直接在输出的地方进行判断
        System.out.println(a==b);//直接进行判断答案为false

5、 逻辑运算符

int i =10;
       int j = 20;
        System.out.println( i > 100 && ++j>99);//逻辑短路即&&以后的不执行
        System.out.println(j);//j打印为20
        System.out.println(i > 100 & ++j>99);//但此时普通逻辑运算会执行
        System.out.println(j);//打印为21

 6、三元运算符

格式：条件表达式 ?  值1 : 值2

        关系表达式的值，如果值为true，返回值1，如果为false，返回值2。

    int a = 18;
       //字符串型第一个字母要大写
       String c = a>=18 ? "成年了": "未成年"; //想要输出的类型定义，要是数字的话定义int
        System.out.println(c);  //输出成年了

7、运算符的优先级 

8、JAV程序API输入函数

package com.learn.Heima.ZS;
import java.util.Scanner;
public class DO1 {
    public static void main(String[] args) {
//    输入函数使用
//        1、导包在顶部导入一个Scanner的包；（ideale软件中输入在使用Scanner时会自动导包）
//        2、抄写代码得到一个输入函数
        Scanner Y = new Scanner(System.in);//Scanner后面的Y是自己设置的名字
//        3、调用Y.使用输入功能
//        实例：
        System.out.println("请输入你的年龄");
        int age =Y.nextInt();  //接受上面从接受到的数据，因为设置的是nextInt则接收int型
        System.out.println("你的年龄是" + age);
        System.out.println("请输入你的姓名");
        String name = Y.next(); //接受上面从接受到的数据，因为设置的是nextInt则接收string型
        System.out.println("你的姓名是" + name);
    }
}

9、关于System.out.println用方法

        换行可以直接用 System.out.println( );//里面为空就行

        打印一行多个的时候用System.out.print( );//不带ln

 三、流程控制

1、分支结构

1、if语句

  if分支有三种形式:
        1、if（条件表达式）{
            代码
        }
        2、if（条件表达式）{
            代码
        }else{代码}
        3、if (条件表达式1) {
            代码1;
        } else if (条件表达式2) {
            代码2;
        } else if (条件表达式3) {
            代码3;
        } else {
            代码n;
        }

2、switch语句 

     语法：
        switch(表达式){
            case 值1:  执行代码...;
                break;
            case 值2: 执行代码...;
            break;
             case 值n-1: 执行代码...;
             break;
             default:执行代码n;}

正常使用switch的时候，不要忘记写break，否则会出现穿透现象。 

利用穿透简化程序
            a = 1;
            switch(a){
                case 1:
                case 2:
                case 3:
                    System.out.println("我爱学习");
                    break;
                    //此处1-3都进行打印我爱学习
            }

2、循环结构

1、for循环{先判断后执行}

  语法：
        for (初始化语句; 循环条件; 迭代语句) 
        {	循环体语句(重复执行的代码);
            }

2、while循环 {先判断后执行}

语句：
        初始化语句
        while(循环条件){
            循环体语句（被重复的代码）；
            迭送代码（变量的自增）
        }

3、do-while循环 {先执行后判断}

  语句：
        初始化语句;
        do {
            循环体语句;（循环的语句）
            迭代语句;（变量变化）
        } while (循环条件);
     重点：do -while 不管怎么样都要执行一次
     例如：
            do{
                System.out.println("hello world");

            }while (false);//会打印 helloworld一次

4、 死循环

 语法 ：
        for ( ; ; ) {
            System.out.println("Hello World1");}//无限循环出helloworld
       
        while (true) {
            System.out.println("Hello World2");}//无限循环出helloworld
       
        do { 
            System.out.println("Hello World3");//无限循环出helloworld
        } while (true);

5、循环嵌套 

外部循环每循环一次，内部循环会全部执行完一轮

 //打印此类时，外为行内为列
        for (int i =0;i<3; i++){
            for (int j =0;j<2;j++){
                System.out.print("💕");//去掉ln会打印一行的
            }
            System.out.println( );//结果为每行两个心，存在三行
        }

6、跳转关键字：break、continue 

break   :  跳出并结束当前所在循环的执行。

continue:  用于跳出当前循环的当次执行，直接进入循环的下一次执行。

7、生成随机数 Random的使用

import java.util.Random;//第一步导报
public class learn1 {
    public static void main(String[] args) {
        //1、导包；2、拿到随机数； 3、调用随机数
        Random Y = new Random(); //第二步,定义Y拿到随机数对象
        int num1 = Y.nextInt(10);//第三步，调用随机函数0-9的随机数
        //注意：nextInt(n)功能智能生成0-n-1的随机数，不包含n
        System.out.println(num1);//打印一个随机数
    }
}

8、Random生成指定区间随机数。 

公式：
    Random Y = new Random();
	//要求打印N-M之间的随机数（为整数）
    int num = Y.nexInt(M-N)+N
 //减加法
        Random Y = new Random();
       // 加入需要打印1-10内的随机数则使用减加法；整体减1，在括号外+上刚减去的
        int num1 = Y.nextInt(9)+1;//此直接打印1-10
        //打印9-66也是同理
        int num2 = Y.nextInt(57)+9;//此处则打印9-66的数字
        System.out.println(num2);

四、数组 

1、静态数组

1、静态化初始化数组=定义数组的时候直接给数组赋值。

   1、数组的初始化
    格式：
       数据类型 数组名[] ={元素1，元素2，...，元素n};
    例如：
       int ege[] = {11,12,55,66,99};
   2、数组的访问
     格式：
        数组名[索引]
        System.out.println(ege[0]);//即打印上方的11
   3、修改数组中的数据
       直接 数组名[索引] =数据；
     例如：
        ege[0]=22;//把下标为0的11改为了22
   4、数组的长度（数组元素个数）
        System.out.println(ege.length);//5个元素
       技巧：获取数组的最大索引:arr.length-1(前提是数组中存在数据) 
          System.out.println(ege.length-1);//最大索引下标为5

2、数组的遍历 

        就是一个一个数据的访问。

列如
 int[] ages = {20, 30, 40, 50};
        for (int i = 0; i < ages.length; i++) 
        {   System.out.println(ages[i]);//依次以0为所以打印到数组的长度
            }

2、动态初始化数组 

        定义数组时先不存入具体的元素值，只确定数组存储的数据类型和数组的长度

 格式：
        数据类型[] 数组名 = new 数据类型[长度]；
     如： int  arr[] =new int[2];//定义一个int类型的2个长度的数组

1、动态初始化数组元素默认值规则： 

数据类型	明细	默认值
基本类型	byte、short、char、int、long	0
	float、double	0.0
	boolean	false
引用类型	类、接口、数组、String	null

2、多个数组变量，指向同一个数组对象 

int arr1[] = {1,2,2,3,6,5,9};
       int arr2[] = arr1;
        System.out.println(arr2[0]);//打印1，因为于arr1指向了同一个地址
        arr2[2]=6;
        System.out.println(arr1[2]);//改变了arr2的值，同时arr1的值也发生了变化，因为在同一个地址

五、 方法 

1、概述

方法是一种语法结构，它可以把一段代码封装成一个功能，以便重复调用

语法：
        修饰符  返回值类型  方法名( 形参列表 ){
            方法体代码(需要执行的功能代码)
        }

示例：

 调用：

2、方法的其他形式及问题

 形式：

 形式1：  public  static  void print(){
        System.out.println("hello world");
    }//无参数，无返回值声明
形式2：  public static void printHelloWorld(int n){
      for(int i=1;i <= n; i++){
          System.out.println("Hello World");}
  }有参数，无返回值方法

问题： 

 public static int sum(int a, int b){
        int c =a + b;
        return c;}
    public static void main(String[] args) {
        1、 方法在类中的位置放前放后无所谓，但一个方法不能定义在另一个方法里面。
        2、方法的返回值类型写void（无返回申明）时，方法内不能使用return返回数据，如果方法的返回值类型写了具体类型，方法内部则必须使用return返回对应类型的数据。
        3、return语句的下面，不能编写代码，属于无效的代码，执行不到这儿。
        4、方法不调用就不会执行,  调用方法时，传给方法的数据，必须严格匹配方法的参数情况。
        5、调用有返回值的方法，有3种方式：
        1、可以定义变量接收结果
        int rs =sum(a:10，b:20);
        System.out.println(rs);
        2、或者直接输出调用，
        System.out.println(sum(a:10，b:90)):
        3、甚至直接调用；
        sum( a: 100,，b:200);
        6、调用无返回值的方法，只有1种方式：只能直接调用。
    }

3、Java的参数传递机制 都是：值传递

 所谓值传递：指的是在传输实参给方法的形参的时候，传输的是实参变量中存储的值的副本。

实参：在方法内部定义的变量。    

形参：定义方法时“(…)”中所声明的参数。

1、基本类型的参数传输存储的数据值。

 基本类型的参数传递：基本类型的参数传输存储的数据值。改变不了值
        public class Test {   public static void main(String[] args) {
            int a = 10;
            change(a);
            System.out.println(a); // 10
             }
             public static void change(int a){
            System.out.println(a); // 10
               a = 20;
               System.out.println(a); // 20
                 }
                  }

2、引用类型的参数传输存储的地址值。

主要学习了引用数组可以改变传输存储的数据值

例如：

 public static void main(String[] args) {
        System.out.println("Hello World");
        int [] arr = {10,20,30};
        change(arr);
        System.out.println(arr[1]);//打印222
    }
    public static  void change(int [] arrs){
        System.out.println("方法1："+arrs[1]);//打印20
        arrs[1] = 222;
        System.out.println("方法2："+arrs[1]);//打印222
    }

4、方法重载 

一个类中，只要一些方法的名称相同、形参列表不同（形参的个数、类型、顺序不同），那么它们就是方法重载了，其它的都不管

例如：

public static void test(){
        System.out.println("===test1===");
    }//1、无形参

    public static void test(int a){
        System.out.println("===test2===" + a);
    }//2、有形参

    void test(double a){
        //3、有形参不同类型
    }

    void test(double a, int b){
        //4、两个形参
    }

    void test(int b, double a){
        //5、两形参不同顺序
    }

5、在方法中单独使用return关键字 

return; 可以用在无返回值的方法中，作用是：立即跳出并结束当前方法的执行。

break; 跳出并结束当前所在循环的执行。

continue; 结束当前所在循环的当次继续，进入下一次执行

六、类与对象

1、类与对象 

语法：
1、先创建一个类
   public class 类名{
    1、变量，用来说明对象可以处理什么数据
    2、方法，描述对象有什么功能，也就是可以对数据进行什么样的处理
    }
2、在别的类中（main）在使用创建的对象
    类名 对象名 = new 类名();
    对象名.里面的变量；
    对象名.里面的方法进行打印

例如：

public class Student {//在外面建立一个类
    String name;// 姓名
    //建立一个方法在里面打印
    public na(String name) {
        System.out.println("我是"+name);
    }
}
//在main函数中使用
    Student pr = new Student();
    pr.name = "张三";
    //调用类里面建立的方法
    pr.na();

2、注意事项 

1、类名建议用英文单词，首字母大写，满足驼峰模式，且要有意义，比如：Student、Car…
2、类中定义的变量也称为成员变量（对象的属性），类中定义的方法也称为成员方法（对象的行为）。
3、成员变量本身存在默认值，同学们在定义成员变量时一般来说不需要赋初始值（没有意义）。{一般字符串型为null，其余为0}
4、一个代码文件中，可以写多个class类，但只能一个用public修饰，且public修饰的类名必须成为代码文件名。
5、对象与对象之间的数据不会相互影响，但多个变量指向同一个对象时就会相互影响了。
6、如果某个对象没有一个变量引用它，则该对象无法被操作了，该对象会成为所谓的垃圾对象。

3、This 

1、this就是一个变量， 可以用在方法中 ，用来拿到当前对象；
 2、哪个对象调用方法，this就指向哪个对象，也就是拿到哪个对象。
3、用来解决对象的成员变量与方法内部变量的名称一样时，导致访问冲突问题的。
如： 

    double score ;
    public void pr( double score ) {
      if (score >score) //两个相同的score不好判断
          // 所以用this
      if (this.score >score)//this.score指向了类中的score变量
        }

4、构造器 

1、什么是构造器 

构造器是一种特殊的方法，这个方法没有返回值类型；方法名与类名一模一样
public class Student {
public Student(){}//创建一个无参方法，方法名与类名相同的
    public Student(double score){}//创建一个有参方法，方法名与类名相同的
}

2、构造器的使用

创建对象时，对象会去调用构造器。 
    Student s1 = new Student();//没有传输数据的时候，会使用没有参数的方法
    Student s2 = new Student(100);//传入数据的时候，会直接使用带参数的构造器的

5、封装 （合理隐藏，合理暴露）

公开使用public(公开)进行修饰。

隐藏使用private(私有，隐藏) 进行修饰。

理解：

//封装就是就是用类设计对象处理某一个事物的数据时，应该把要处理的数据，以及处理这些数据的方法，设计到一个对象中去。
private double score;//私有数据，不允许类以外的访问
    public void sum(double score) {
        this.score = score//此处就可以给score赋值了
        //公有的方法，外面设立的对象只能调用此方法
    }

6、 实体JavaBean

实体要求;

    1、必须私有成员变量，并为每个成员变量都提供getset方法

    2、必须为类提供一个公开的无参数构造器

    3、实体类只负责数据存取，而对数据的处理交给其他类来完成，以实现数据和数据业务处理相     分离

实例应用：

7、成员变量、局部变量的区别 

1、类中位置不同:成员变量(类中，方法外)、局部变量(常见于方法中)
2、初始化值不同:成员变量(有默认值，不需要初始化赋值)，局部变量(没有默认值，使用之前必须完成赋值)

3、内存位置不同:成员变量(存在于堆内存)，局部变量(栈内存)
4、作用域不同:成员变量(整个对象)，局部变量(在所归属的大括号中)
5、生命周期不同:成员变量(与对象同生共死)，局部变量(方法调用而生，方法结束而亡)

七、API

1、包

注意事项：  

1、如果当前程序中，要调用自己所在包下的其他程序，可以直接调用。（同一个包下的类，互相可以直接调用）

2、如果当前程序中，要调用其他包下的程序，则必须在当前程序中导包, 才可以访问！导包格式：import 包名.类名;

3、如果当前程序中，要调用Java提供的程序，也需要先导包才可以使用；但是Java.lang包下的程序是不需要我们导包的，可以直接使用。

4、如果当前程序中，要调用多个不同包下的程序，而这些程序名正好一样，此时默认只能导入一个程序，另一个程序必须带包名访问。 

 Demo2 d = new Demo2();
  d.对象里面的方法
    //类名相等的情况下，需要包全名
    learn.Demo2 u =new learn.Demo2()

2、String 

1、String概述

实例应用：

     //1、直接双引号得到字符中对象，其装字符电数据
        String name = "it黑马";//创建一个空白字符串对象，不含有任何内容
        System.out.println(name);//it黑马

     //2、调用String类的构适器初始化字符串对象
        // new String创建字符申对象，并用构造器初始化字符申
        String rs1 = new String();//根据传入的字符串内容，来创建字符串对象
        System.out.println(rs1);//没放入值输出空

        String rs2 = new String("itheima");
        System.out.println(rs2);//itheima

        char[] chars = {'a','黑','马'};//根据字符数组的内容，来创建字符串对象
        String rs3 = new String(chars);
        System.out.println(rs3);//a黑马

        byte[] bytes = {97,98,99};
        String rs4 = new String(bytes);//根据字节数组的内容，来创建字符串对象
        System.out.println(rs4);//abc{ACII对应的编号}

2、String的常用方法 

 实例应用：

    String s = "itjava";
    //1、获取字符串长度  length()
        System.out.println(s.length());//6
    //2、提取字符串中某个索引位置处的字符 charAt(下标)
        char c=s.charAt(1);//报取下标为1的字符
        System.out.println(c);//t
    // 3、把字符串转换成字符数组，再进行历 toCharArray
        char chars[]=s.toCharArray();
        for(int i=0;i<chars.length;i++){
            System.out.println(chars[i]);//依次打印字符串里面的每个数据单位
        }
    //4、判断字符串内容， 内容一样就返回true，否则返回false | equals()
        String s1 =new String("黑马");
        String s2 =new String("黑马");
        System.out.println(s1==s2);//false;因为==是判断两个地址是不是一样
        System.out.println(s1.equals(s2));//true判断的是两个内容
    //5、忽略大小写比较字符串内容 equalsIgnoreCase()
        String c1 ="jAVAit";
        String c2="javaIT";
        System.out.println(c1.equalsIgnoreCase(c2));//true
    // 6、截取字符串内容(包前不包后)substring(起始下标，结束下表)
        String s3 ="JAVA是最好的编程语言之一";
        String rs=s3.substring(0,8);//截取下表为0到下表为1的数据
        System.out.println(rs);//JAVA是最好的
    //7、从当前索引位置一直截取到字符串的未尾 substring(8)
        String rs2=s3.substring(8);//截取从下表为5到字符串结尾的数据
        System.out.println(rs2);//编程语言之一
    // 8、把字符串中的某个内容替换成新内容，并返回新的字符串对象 replace(要替换的内容，替换成的内容)
        String infor ="这个电影简直是个垃圾，垃圾电影！！";
        String rs3 = infor.replace("垃圾","**");
        System.out.println(rs3);//这个电影简直是个**，**电影！！
    //9、判断字符申中是否包含个关键字  contains(要查询的内容)
        String infor2 ="java是最好的编程语言之一,我爱java，java不爱我！";
        System.out.println(infor2.contains("java"));//true
        System.out.println(infor2.contains("python"));//false
    //10、判断字符串是否以某个字符串开头 startsWith(内容)
        String rs4 = "张三丰";
        System.out.println(rs4.startsWith("张"));//true
        System.out.println(rs4.startsWith("张三"));//true
        System.out.println(rs4.startsWith("张三丰"));//true
        System.out.println(rs4.startsWith("张三丰2"));//false
    //11、把字符串按照某个指定内容分割成多个字符串，放到一个字符串数组中返回给我们
        String rs5 = "张无忌,周芷若,殷素素,赵敏";
        String[] names=rs5.split(",");//以逗号隔开放进数组
        for(int i=0;i<names.length;i++){
            System.out.println(names[i]);
        }//张无忌 周芷若 殷素素 赵敏

3、String使用时的注意事项 

String是不可变字符串对象

只要是以“...”方式写出的字符串对象，会存储到字符串常量池，且相同内容的字符串只存储一份； 但通过new方式创建字符串对象，每new一次都会产生一个新的对象放在堆内存中。