Java基础 复习

Java基础 复习

以下内容来自于视频学习的笔记: 狂神说Java.
IDEA 快捷键

• Ctrl+Alt+L 自动对齐代码
• Ctrl + D 复制当前行到下一行
• Alt+Enter 自动排错，没有的包可以自动导入
• Ctrl+鼠标点击方法，可以跳转
• Alt+Insert 自动生成构造器,get，set方法
• Ctrl+H 光标在某个类里时，使用快捷键，右侧会生成类树
• Ctrl+Alt+T 在需要包裹的代码处，可以选择包裹方式，比如生成try catch

1. 注释

   • 单行注释 //
   • 多行注释 /* */
   • 文档注释

2. 标识符

类名、变量名以及方法名都被称为标识符。以字符、美元符号或下划线开始

，首字母之后可以是字母、美元符号、数字或者下划线的组合，标识符大小写敏感

可以使用中文，但是最好不要

关键字如下图：

3. 数据类型

   • 基本类型：数值类型（整数类型[byte一个字节、short两个字节、int四个字节、long八个字节]、浮点类型[float四个字节、double八个字节]、字符类型[char两个字节]）、boolean类型（一个字节，值只有true和false）

   //整数
   int num1 = 10; //最常用
   byte num2 = 20; 
   short num3 = 30;
   long num4 = 30L; //Long类型要在数字后加个L
   //小数：浮点数
   float num5 = 50.1f; //float型要在后边加F,不然double
   double num6 = 3.23333333;
   //字符
   char name = 'A';
   //字符串，String不是关键字，类
   //String name = '哆啦梦'
   //布尔值
   boolean flag = true;
   //boolean flag = false;
   
   

   • 引用类型： 类、接口、数组

5. 类型转换

   • 强制转换 （类型）变量名 高–>低

   • 自动转换 低 -->高

     注意：1.不能对布尔值进行转换

     2.不能把对对象类型转换为不相干的类型

     3.转换的时候可能存在内存溢出，或精度类型

   • 补充：JDK7特性，数字之间可以用下划线分隔，不影响

     int mone = 1_0000_0000;//下划线分隔
     int year = 20;
     //先把一个数转换为long型，避免溢出
     long total = (long)money * year ;
     

6. 变量

   • 每个变量必须声明其类型，基本类型或引用类型
   • 命名：首字母小写和驼峰原则
   • Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域（类变量、实例变量、局部变量）
     • 实例变量：从属于对象，如果不自行初始化，则为这个类型的默认值（bool类型默认值false，除了基本类型，默认类型为null）

7. 常量

   修饰符（下图紫色部分）不区分顺序

   static  final double PI = 3.14;
   

   常量命名：一般大写字符和下划线：MAX_VALUE

   补充：

   • 类名：首字母大写和驼峰原则：Man,GoodMan
   • 方法名：首字母雄安写和驼峰原则
   • 包名：小写

8. 运算符 [使用括号区分优先级]

   • 算术运算符 包括自增、自减

     //补充连接符号 + 只要加号的内容出现字符串类型，则变成字符串拼接
     int a = 1;
     int b = 2;
     System.out.println(a+b+'');//输出3
     System.out.println(''+a+b);//输出12 
     

   • 赋值运算符

   • 关系运算符 返回结果为bool值

   • 逻辑运算符： && 、||、~、<<左移x2，、>>右移x2

     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));//逻辑非运算
     //注意&&与如果第一个错了，则后边不执行；||同理
     

   • 位运算符

   • 条件运算符 ？：

     //x?y:z
     int score = 80;
     String type = score<60?"不及格":"及格";
     System.out.println(type);
     

   • 拓展运算符

     补充：幂运算

     double pow = Math.pow(2,3);
     System.out.println(pow);
     

9. 包机制

   为了更好地组织类，Java提供了包机制，用于区别类名的命名空间

   • 包语句的语法格式为：package pkg1[.pkg2[.pkg3…]];

   • 一般利用公司域名倒置作为包名：www.baidu.com com.baidu.www

   • 为了能够使用某个包的成员，我们需要在Java程序中明确导入该包，使用“import”语句可完成此功能

     import package1[.package2...].(classname|*);
     //注意加分号
     

10. JavaDoc

    • javadoc命令是用来生成自己的API的

      /**
      @author:
      @version:
      @since: 指明需要最早使用的jdk版本
      @param: 参数名
      @return:返回值情况
      @throws:异常抛出情况
      */
      

      • 使用cmd生成文档

        //在左侧目录需要生成文档的类，右键->Show in Explorer->导航栏打开cmd
        

    javadoc -encoding UTF-8 -charset UTF-8 Doc.java
    回到文件管理器，出现了.html文件即为生成的文档

      ```
    

    • 也可使用IDEA生成javaDoc文档

      Tools -> Generate JavaDoc->选择要生成文档的File->选择生成文档的输出目录Ouput directory ->选择Locale：zh_CN->传入JavaDoc的参数，一般写成： -encoding UTF-8 -charset UTF-8 -windowtitle “文档HTML页面标签的标题” -link http://docs.Oracle.com/javase/7/docs/api

      然后找到生成的html

    Java流程控制

    1. Scanner对象 实现程序和人的交互，可以通过Scanner类获取用户输入

       Scanner s = new Scanner(System.in);
       

       通过Scanner类的next()和nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

       • next()：
         1.一定要读取到有效字符后 才可以结束输入。
         2. 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
         3. 只有输入有效字符后才将其后边输入的空白作为分隔符或者结束符
         4. next()不能得到带有空格的字符串。

       Scanner scanner = new Scanner(System.in);//程序会等待用户输入结束
       System.out.println("使用next方式接收：");
       //判断用户有没有输入字符串
       if(scanner.hasNext()){
                
           //
           String str = scanner.next();//
           System.out.println("输出的内容为"+str);
       }
       //凡是属于IO流的类如果不关闭会占用资源，用完就关闭
       scanner.close();
       

       2. nextLine():
          以Enter为结束符，也就是说nextLine()方法返回的是输入回车之前的所有字符。
          可以获得空格。

       Scanner scanner = new Scanner(System.in);//程序会等待用户输入结束
       System.out.println("使用nextLine方式接收：");
       //判断用户有没有输入字符串
       if(scanner.hasNextLine()){
                
           //
           String str = scanner.nextLine();//
           System.out.println("输出的内容为"+str);
       }
       //凡是属于IO流的类如果不关闭会占用资源，用完就关闭
       scanner.close()
       

    2. 顺序结构

       • JAVA的基本结构是顺序结构

    3. 选择结构

       • if单选择结构

         Scanner scanner = new Scanner(System.in);
         Stirng s = scanner.nextLine();
         if(s.equals("hello")){
                    
             System.out.println("End");
         }
         

       • if双选择结构

         if(布尔表达式){
                    
             
         }else{
                    
             
         }
         

       • if多选择结构

         if(布尔表达式){
                    
         
         }else if(){
                    
            
         }else{
                    
            
         }
         

       • if嵌套结构

       • switch多种选择结构

         • switch case语句判断一个变量与一系列值中某个值是佛相等，每个值称为一个分支；
         • 表达式可以是byte、short、int、char类型，从JDK7开始，可以是字符串

         switch(expression){
                    
             case value1:
                 //语句
                 break;//可选
             case value2:
                 //语句
                 break;//可选
             // 可以有任意数量的case语句
             default: //可选
                 //语句       
                 
         }
         

    4. 反编译

       P37后半部分

       从project结构中，找到文件生成的class文件的位置，从文件夹中复制该class文件到源代码位置。

    5. 循环结构

       • while循环

         - while(布尔表达式){
                    
         
            //循环内容
          
         }
         

       • for 循环

         for(初始化；布尔表达式；更新){
                    
             //代码
         }
         //在IDEA中，输入100.for回车,则会自动生成下面
         for(int i = 0; i < 100; i++){
                    
             
         }
         

         增强for 循环

         int[] numbers = {
                    0,20,30,40,50}; //定义一个数组
         //遍历数组元素
         for(int x:numbers){
                    
             System.out.println(x); //这样会输出数字钟每一个元素
             
         }
         
         

       • do–while循环

         do{
                    
                
         }while(布尔表达式);
         

    6. break & continue

       break跳出循环，continue 终止本次循环

    7. 方法

       • 方法是语句的集合，他们一起执行一个功能

       修饰符(可选) 返回值类型 方法名(参数类型 参数名){
                
           方法体
            return 返回值
       }
       

    8. 方法调用：调用方法：

       • 对象名.方法名（）

    9. 方法的重载

       • 方法名称必须相同，参数列表必须不同
       • 方法的返回类型可以相同也可以不同
       • 仅仅返回类型不同不足以成为方法的重载

    10. 命令行传参

        P48

    11. 可变参数

        • 方法声明中，在指定参数类型后加一个省略号(…)

        • 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数，任何不同的参数必须在它之前声明。

          public void test(int...i){
                     
              //调用时，可以输入参数整数，如下但因输入的第一个整数
              System.out.println(i[0]);
          }
          

    12. 递归

        • 方法自己调用自己

        • 递归头：什么时候不调用自身方法，如果没有头，将陷入死循环

    13. 数组

        • 相同类型数据的有序集合

        • 可以通过下标访问

          int[] nums;//1.声明一个数组
          nums = new int[10];// 2.创建一个数组
          nums[0] = 1; //3.给数组元素赋值，如果不赋值，则为对应类型的默认值
          //获取数组长度：arrays.length
          

    • 初始化方法

      • 静态初始化：创建+赋值

        int[] a = {
                   1,2,3};
        

      • 动态初始化

        int[] a = new int[2];
        a[0] = 1;
        a[1] = 2;
        

      • 数组默认初始化

        数组时引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量童颜给的方式被隐式初始化

    14. 数组的基本特点

    - 长度确定，数组一旦被创建，它地打小就不可改变
    - 元素是相同类型
    - 数组中的元素可以是任何数据类型，包括基本类型和引用类型
    - 数组本身就是对象，Java对象是在堆中地，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。
    

    15. 数组的使用

        • For-循环
        • 数组作方法入参
        • 数组作返回值

    16. 多维数组

        //二维数组为例
        int[][] array = {
                 {
                 1,2},{
                 2,3},{
                 3,4}};
        for(int i=0;i<array.length;<i++){
                 
            for(int j = 0;j<array[i].length;j++){
                 
                System.out.println(array[i][j]);
            }
        }
        

    17. Arrays类

        import java.util.Arrays;
        //打印数组元素 Arrays.toString()
        int[] a = {
                 1,2,4,3,9090};
        System.out.println(Arrays.toString(a)); 
        //会打印出[1, 2, 4, 3, 9090]
        //Arrays.sort(数组名) 对数组进行排序
        Arrays.sort(a);
        Arrays.toString(a); //排序后输出为[1, 2, 3, 4, 9090]
        

        • 给数组赋值：fill方法
        • 数组排序：sort方法，升序
        • 比较数组：通过equals方法比较数组中元素值是否相等
        • 查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法

    18. 冒泡排序

        //从大到小
        public static int[] sort(int[] array){
                 
            int temp = 0;
            
            //外层循环，判断轮数
            for(int i = 0; i<array.length-1; i++){
                 
                //内层循环，比较判断两个数
                for(int j =i; j< array.length-2-i;j++){
                 
        			if(array[j+1]>array[j]){
                 
                        temp = array[j];
                        array[j] = array[j+1];
                        array[j+1] = temp;
                    }            
                }
            }
            return array;
            
        }
        

    19. 稀疏数组

        稀疏数组的处理方式：

        • 记录数组移动有几行几列，有多少个不同的值

        • 把具有不通知的元素和行列及值记录在一个小规模的数组中中，从而缩小程序的规模

        面向对象

    20. 面向对象

        以类的方式组织代码，以对象的方式的组织（封装）数据

    21. 三大特性

        • 封装
        • 继承
        • 多态

    22. 静态方法 static 非静态方法

        类名.方法名 可调用静态方法

        如果为非静态方法，需要先实例化一个对象

        public class Student{
                 
            //非静态方法
            public void say(){
                 
                System.out.println("学生说话");
            }   
        }
        Student student = new Student();
        student.say();
        
        //加上static后，可以直接Student.say()调用
        

    23. Java是值传递

    24. • 类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
        • 对象是抽象概念的具体实例

    25. 创建与初始化对象

        • 使用new关键字创建对象
          • 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
          • 类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的，并且构造器有以下两个特点：
            1. 必须和类的名字相同
            2. 必须没有返回类型，也不能写void

        public class Person{
                 
            //一个类即使什么都不写，它也会存在一个方法
            //显式地定义构造器
            String name;
            //实例化初始值
            //使用new关键字，本质在构造器
            //用来初始化值
            public Person(){
                 
                //this.name = "小鱼儿";
            }
            //有参构造：一旦定义了有参构造，无参就必须显式构造
            //如果没有有参构造，可以自动生成隐式无参构造
            public Person(String name){
                 
                this.name = name;
            }
        }
        

    26. 封装

        • “高内聚、低耦合”

        通常，应禁止直接访问一个对象中数据地实际表示，而应通过操作接口来访问，这称为信息隐藏

        • 提高程序地安全性，保护数据
        • 统一接口，提高系统可维护性

        属性私有，get/set

        public class Student{
                 
            //属性私有，无法直接实例名.属性来更改
            //名字
            private String name;
            //学号
            private int id;
            //姓名
            private char sex;
            //get 获得这个数据
            public String getName(){
                 
                return this.name;
            }
            //set 给这个数据设置值
            public void setName(String name){
                 
                this.name = name;
            }
            
        }
        

    27. 继承

        • 本质是对某一批类地抽象，从而实现对现实世界更好建模
        • extends,子类是父类地扩展
        • JAVA类中只有单继承，没有多继承

        //定义Person类，Student类是Person类的子类
        public class Student extends Person{
                 
               
        }
        

    28. public protected default private

    29. 在Java类中，所有的类都默认直接或者间接继Object类

    30. Super

        • super调用父类的构造方法必须在构造方法的第一个
        • super必须只能出现在子类的方法或者构造方法中
        • super和this不能同时调用构造方法

    31. super和this

        • 代表的对象不同： this:本身调用者这个对象

          ​ super:代表父类对象的应用

          • 前提： this没有继承也可以使用

            ​ super:只能在继承条件才可以使用

          • 构造方法： this():本类的构造

            ​ super()：父类的构造

    32. 方法的重写

        • 重写需要有继承关系，子类重写父类的方法

        • 参数列表必须相同

        • 修饰符：范围可以扩大，public>Protected>Default>private

        • 抛出的异常：范围，可以被缩小，但不能扩大

        • 重写都是方法的重写，与属性无关

        • 非静态方法，才叫重写，而且需要public

    33. 多态

        即同一方法可以根据发送兑现给的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类、有关系的类）。

        //一个对象的实际类型是确定的
        new Student();
        new Person();
        //可以指向的引用类型不确定了，父类的引用指向子类
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        //对象能执行的方法，主要看对象左边的类型
        

        • 多态是方法的多态，属性没有多态

        • 父类和子类，要有联系。

        • 存在条件：继承关系，子类重写父类方法，父类引用指向子类对象

    34. instanceof

        System.out.println(X instanceof Student);
        //能否编译通过取决于X和Y之间是否有父子关系
        

        子类转化为父类，可能丢失一些方法

    35. static

        静态属性

        public class Student{
                 
            private static int age;//静态的变量 多线程！
            private double score;//非静态的变量
            
            public static void main(String[] args){
                 
                Student s1 = new Student();
                System.out.println(Student.age);//建泰属性直接使用类名调用即可
                System.out.println(s1.age);//非静态属性实例化后
                System.out.println(s1.score);
            }
            
        }
        

        静态方法

    36. 抽象类

        //抽象类 ，单继承
        public abstract class Action{
                 
            //约束 
            public abstract void doSomething();
            
        }
        

        • 不能new这个抽象类，只能靠子类去实现它：约束

        • 抽象类中可以写普通的方法~

        • 抽象方法必须要在抽象类中~

    37. 接口

        普通类：只有具体实现

        抽象类：具体实现和规范(抽象方法)都有！

        接口：只有规范。约束和实现分离：面向接口编程

        声明接口的关键字是interface

        接口中的所有定义其实都是抽象的public abstract

        public interface UserService{
                 
            void add(String name);
            void delete(String name);
            void update(String name);
            void query(String naem);
        }
        

        定义接口后，写它的实现

        //类实现接口，implements 接口
        //实现接口中的类，就需要实现其中的方法
        public class UserServiceImpl implements UserService{
                 
            
        }
        //利用接口实现多继承
        

        接口的作用：1.约束 2.定义一些方法，便于分工

        • 接口不能被实例化，接口中没有构造方法
        • implements可以实现多个接口

    38. 内部类

        就是在一个类的内部再定义一个类，比如A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类.

        比如

        public class Outer{
                 
            private int id;
            public void out(){
                 
                System.out.println("这是外部类的方法")；
            }
            public class Inner{
                 
                public void in(){
                 
                    System.out.println("这是内部类的方法");
                }
            }
        }
        

        • 成员内部类
        • 静态内部类
        • 局部内部类
        • 匿名内部类

    39. 异常

        • 异常处理五个关键字：try、catch、finally、throw、throws

        • Error和Exception:Error通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机一般会选择终止线程；Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能地去处理这些异常。

          int a = 1;
          int b = 0;
          try{
                     //try监控区域
              System.out.println(a/b);
          }catch(ArithmeticException e){
                     
              System.out.println("程序出现异常，变量b不能为0");}finally{
                     //处理善后工作
              System.out.println("finally");   
          }
          //finally 可以不要finally
          

    40. 自定义异常

        public class MyException extends Exception{
                 
        	
        }