Java基础知识复习

运算符：
  - 算术运算符  +  -  *  /
  - 赋值运算符  += -=  *= /=  %=  取余
  - 比较运算符（关系运算符）  >=  <=  >  < 
  - 逻辑运算符  &  
  &&   1. 两边都是true，结果是true 
  2. 一边是false，结果是false.
  短路特点：符号左边是false，右边不再运
  ||  
  1. 两边都是false，结果是false<br /> 
  2. 一边是true，结果是true <br />
  短路特点： 符号左边是true，右边不再运算
  - 条件运算符（三元运算符）a>b?true?false
  定义格式
  修饰符 返回值类型 方法名 （参数列表）｛
    代码...
    return ;
｝

方法定义注意事项：

- 方法必须定义在一类中方法外

- 方法不能定义在另一个方法的里面 

switch(表达式) { 
    case 常量值1: 
            语句体1;
            break; 
    case 常量值2: 
            语句体2; 
            break; 
        ... 
    default: 
            语句体n+1; 
            break;
    }
    
    
    public static void main(String[] args) { 
    //定义变量，判断是星期几 
    int weekday = 6; 
    //switch语句实现选择 
    switch(weekday) { 
        case 1: 
            System.out.println("星期一"); 
            break; 
        case 2: 
            System.out.println("星期二"); 
            break; 
        case 3:
            System.out.println("星期三"); 
            break; 
        case 4: 
            System.out.println("星期四"); 
            break; 
        case 5:
            System.out.println("星期五"); 
            break; 
        case 6: 
            System.out.println("星期六");
            break; 
        case 7: 
            System.out.println("星期日"); 
            break; 
        default: 
            System.out.println("你输入的数字有误"); 
            break; 
    }
    
for循环语句格式

- 格式：

```Java
for(初始化表达式①; 布尔表达式②; 步进表达式④){
    循环体③
}
```

- while循环语句格式： 

```java
初始化表达式①
while(布尔表达式②){
    循环体③
    步进表达式④
}
```

  while循环执行流程

- 执行流程

  - 执行顺序：①②③④>②③④>②③④…②不满足为止。

- do...while循环格式 

```java
初始化表达式①
do{
    循环体③
    步进表达式④
}while(布尔表达式②);
```
 do...while循环执行流程

- 执行流程

  - 执行顺序：①③④>②③④>②③④…②不满足为止。    
  - ①负责完成循环变量初始化。
  - ②负责判断是否满足循环条件，不满足则跳出循环。
  - ③具体执行的语句
  - ④循环后，循环变量的变化情况  

 5.1.3 for循环执行流程

# for和while的小区别

- for 和 while 的小区别：
  - 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继
  - 续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消
  - 失，能够提高内存的使用效率。
  - 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while
调用方法的三种形式
    public static void main(String[] args) {
//        直接调用
        as();
//        赋值调用
        int   c=a1(3,3);

        System.out.println("c="+c);

//        输出调用
        System.out.println(a1(6,2));
    }

    private static void as() {
        System.out.println("优秀");
    }

    public   static   int  a1( int a, int b){
        return  a+b;
    }
    
    
    package Stringtixi;

public class Zui {
    public static void main(String[] args) {
//        最大数
        a2();
//        倒叙
        as3();
    }

    private static void as3() {

        int[] arr={23,56,66,100};

        for (int i = 0; i < arr.length; i++) {

            System.out.println(arr[i]);
        }

        System.out.println("--------------");
        for (int min = 0, max=arr.length-1;  min<=max;min++,max--) {

            int  c=arr[min];
            arr[min]=arr[max];
            arr[max]=c;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println("倒叙为"+arr[i]);
        }
    }

    private static void a2() {
        int[] arr={23,56,66,100};
        int c=arr[0];
        for (int i = 0; i < arr.length; i++) {
if(arr[i]>c){
    c=arr[i];
}

        }
        System.out.println("最大数为"+c);
    }
}

    
    --------------------
    面向对象
    
    **类**：是一组相关**属性**和**行为**的集合
    
    
    类和对象的关系

- 类是对一类事物的描述，是抽象的。

- 对象是一类事物的实例，是具体的。

- 类是对象的模板，对象是类的实体。 

public class Ju {
//    成员变量
    String  color;

    public static void main(String[] args) {
//        局部变量
        int c=666;
        Ju ju = new Ju();

        System.out.println(c);
        System.out.println(ju.color);

    }

}
成员变量和局部变量的区别

- 在类中的位置不同 
  - 成员变量：类中，方法外
  - 局部变量：方法中或者方法声明上(形式参数)
- 作用范围不一样 
  - 成员变量：类中
  - 局部变量：方法中
- 初始化值的不同 
  - 成员变量：有默认值
  - 局部变量：没有默认值。必须先定义，赋值，最后使用
- 在内存中的位置不同  
  - 成员变量：堆内存
  - 局部变量：栈内存   (常量池)
- 生命周期不同 
  - 成员变量：随着对象的创建而存在，随着对象的消失而消失
  - 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 
  
  
  #### 构造方法的定义格式★★★

```java
修饰符 构造方法名(参数列表){
    // 方法体
}     
```

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用
构造方法后，代码如下： 

```java
public class Student {
    private String name;
    private int age;
    // 无参数构造方法
    public Student() {}
    // 有参数构造方法
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }
} 
```

注意事项**

1. 如果你不提供构造方法，系统会给出无参数构造方法。
2. 如果你提供了构造方法，系统将不再提供无参数构造方法。
3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。 
  
  //键盘录入，求最大数
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数");
        int a = sc.nextInt();
        System.out.println("请输入第2个数");
        int b = sc.nextInt();
        System.out.println("请输入第3个数");
        int c = sc.nextInt();

        int d=(a>b ? a:b);
        int max=(d>c?d:c);
        System.out.println("最大数为"+max);
    }
    猜数字
    
    private static void as1() {
        Random r = new Random();
        int i = r.nextInt(10);

        for (int k = 0; k <3; k++) {
            System.out.println("请输入第"+(k+1)+"个数");
            int f = sc.nextInt();
            if(f>i){
                System.out.println("输大了");
            }else   if (f<i){
                System.out.println("输小了");
            }else {
                System.out.println("恭喜你猜中了");

                break;
            }
        }

        }
        
        
        --------
        package Stringtixi;

public class Stringr {

    public static void main(String[] args) {

        String   s="s游,记";
        //把字符串转换成字符数组
//        char[] chars = s.toCharArray();
//        for (int i = 0; i < chars.length; i++) {
//            System.out.println(chars[i]);
//        }

//把字符串转换成字节数组
//        byte[] bytes = s.getBytes();
//        for(int x = 0; x < bytes.length; x++) {
//            System.out.println(bytes[x]);
           100
115
98
106
115
//        }

        /*
        *
        * 把s  替换西
        * */

        String replace = s.replace("s", "西");
        System.out.println(replace);
//        分割
        String[] split = s.split(",");
        for (String s1 : split) {
            System.out.println(s1);
        }
    }
}

    

 静态代码块★★★

- 静态代码块：定义在成员位置，使用static修饰的代码块{ }。
  - 位置：类中方法外。
  - 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行     
    
    static 修饰的内容：

- 是随着类的加载而加载的，且只加载一次。
- 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
- 它优先于对象存在，所以，可以被所有对象共享
//    计算在 -10.8 到 5.9 之间，绝对值大于 6 或者小于 2.1 的整数有多少个。
    public static void main(String[] args) {
        // 定义最小值
        double min =-10.8;
        // 定义最大值
        double max = 5.9;
        // 定义变量计数
        int count = 0;
        // 范围内循环
        for (double i = Math.ceil(min); i <= max; i++) {
            // 获取绝对值并判断
            if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
                // 计数
                count++;
            }
        }
        System.out.println("个数为: " + count + " 个");
    }
}

    private static void as5() {

        int[] arr={23,76,66,100};
//转换成字符数组
        String s = Arrays.toString(arr);
        Arrays.sort(arr)  ;

//正序
        String s1 = Arrays.toString(arr);
        System.out.println("正序"+s1);
        System.out.println("---------------");
        for (int i = arr.length-1; i>=0;i--) {
            System.out.println("反序"+arr[i]);
        }
    }
    
    
    - 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。 
- 接口中，没有构造方法，不能创建对象。 
- 接口中，没有静态代码块
被final修饰的常量名称，一般都有书写规范，所有字母都大写。   
 final String USERNAME ;

修饰方法

    修饰符 final 返回值类型 方法名(参数列表){     
    //方法体 
}
权限修饰符介绍
- public：公共的。 
- protected：受保护的 ，同一个类以及同一个包 ，不通包的子类。
- default：默认的 。  同一个类以及同一个包
- private：私有的。在同一个类中

什么是内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为**内部类**，B则称为**外部类**。
**访问特点**

- 内部类可以直接访问外部类的成员，包括私有成员。 
- 外部类要访问内部类的成员，必须要建立内部类的对象

1.什么是JVM？什么是JDK？ 什么是JRE？
答案：jdk：java开发工具包。
      jre：java运行环境
  jvm：java虚拟机
jdk = jre + 开发工具
jre = jvm + 核心类库

1.标示符的概述，组成规则及注意事项？ ***
概述：给类，变量，数组等名字时使用的字符序列。
组成规则：由字母，数字，下划线，$组成。
注意事项：
1）数字不能做开头。
2）不能使用java关键字
3）严格区分大小写，尽量做到见名知意。
2.java关键字的定义，特点并书写几个常用的关键字
被java赋予特殊含义的英语单词，一般由小写英文字母组成。
例如：public static void class int
3.Java三种注释类型
单行注释：// 注释内容
多行注释：/* 注释内容 */
文档注释： /** 注释内容 */

1.java数据类型自动转换的规则  ***
1）boolean类型不能转换为其它类型
2）byte，short，char在进行计算时，会先转换成int类型。
short s1 = 3,s2 = 5;
     2.short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?  ***
s1 = s1 + 1有你部门能不能    这些错。因为s1 + 1结果是int类型，赋值给short类型的s1会发生错误。
s1 += 1没有错。因为+=隐含了一个强制类型转换。
3. 8种基本数据类型及其字节数  ***
byte  short  int   long  float  double  char  boolean
1     2      4    8    4     8      2     1/8

1. i++和++i的异同之处 
共同点：
都是使变量自身加1。
如果单独使用，两者没有任何区别。
i++和++i的使用仅仅针对变量。 5++和++5会报错，因为5不是变量
不同点：
参与计算时，i++是先参与计算，再自身加1.
++i是先自身加1，再参与计算。
如：int a = 5;  
int b = a++;  此时，a是6，b是5.
int a = 5;
int b = ++a;    此时，a是6，b是6.
2.&和&&的区别和联系，|和||的区别和联系  ***
&和&&都可以用作逻辑运算符。
&没有短路特性，&&有短路特性。
|没有短路特性，||有短路特性。
短路特性：
如果&&左边为false，那么右边的表达式内容不会影响到整个表达式的结果，）
1）所以&&左边为false时，右边的表达式不会执行。
如果||左边为true，那么右边的表达式内容不会影响到整个表达式的结果，
2）所以||左边为true时，右边的表达式不会执行。
3.用最有效率的方法算出2乘以8等于多少
    2 << 3
4.基本数据类型的类型转换规则
    1）小的数据放在大的数据类型中时，会自动把小的数据转换成大的数据类型，这叫做自动类型转换。如：double d = 3;  
    2）大的数据放在小的数据类型中时，会发生错误。可以强制的把大的数据转换成小的数据类型。格式为：(要转换的数据类型)要转换的数据
    如：int a = (int)3.14;

1.分支语句有哪些
    if语句和switch语句。
    if语句有3种格式，if格式，if..else格式，if..else if格式，switch有switch..case格式。
    分支语句可以嵌套。
2.switch是的注意事项
    1）case后只能是常量，不能是变量。
    2）break可以省略，但不建议。防止case穿透。
    3）default可以省略，但不建议。除非判断的值是固定的。
    4）default和case之间没有先后关系，一般放在最后面。
3.if多分支语句和switch多分支语句的异同之处
        相同：都是分支语句。
        不同：一般情况if用来判断范围，switch用来判断固定值。

1.简述for循环语句的格式及执行流程    ***
    格式：
    for(循环变量赋初值;循环执行条件;循环变量的变化规律){
            循环体
    }
    执行流程：
    for(1;2;3){
        4
    }
    [1,2],[4,3,2],[4,3,2]...[4,3,2]
    解释：
            1：循环变量赋初值，2：循环执行条件，
        3：循环变量的变化规律，4：循环体
    每组都是以2结尾，2位true，执行下一组大括号，2位false，循环结束。
2.while和do-while循环的区别  ***
    while循环是先执行循环条件，条件为true，执行循环体，而do..while先执行一次循环体，再判断循环条件。所以，while可能一次都不执行，但do.while至少执行一次。
3.break和continue的作用
    break用来结束循环，也可以在case中防止case穿透。
  continue用来结束本次循环。

1.三种流程控制语句
    顺序结构，分支结构，循环结构
2.在JAVA中如何跳出当前的多重嵌套循环？
    在java中，想要跳出多重循环，在外层循环前加上一个标记，使用break的时候
    使用break 标记名可以直接跳出标记的那个循环。
    sn: for(;;){
            for(int i = 0;i < 5;i++){
                if(i == 2){
                    break sn;
                }
            }
    }
3.方法的注意事项 ***
    1）方法不调用，不执行
    2）方法之间是平级关系，可以嵌套调用，但不能嵌套定义
    3）方法定义的时候参数之间用逗号隔开
    4）方法调用时实参一定是一个具体的值。
    5）如果方法有返回值，一定要有return。

1.数组的特征
    数组是具有相同数据类型的元素的有序集合。
    数组元素的使用： 数组名[下标]
    下标是从0开始的
    数组的长度是固定的，length表示数组的长度。
2.数组的初始化方式
    静态初始化：数据类型[] 数组名 = {元素值，元素值...元素值};
    动态初始化：数据类型[] 数组名 = new 数据类型[数组长度];
3.数组操作常见的两个异常及场景  ***
    数组下标越界
    空指针异常
    例如：
    int[] arr = new int[5];
    arr[5];    //没有第6个元素，数组下标越界
    arr = null;    
    arr[0];        //空指针异常

1.什么是类？ ***
    类是具有相同特征的对象的抽象。
2.对象和类的区别是什么
    类是具有形同特征的对象的抽象。
    对象是类的具体体现。
    如：人 -  张三
3.程序设计从开始到现在，大致经历了哪三个阶段？ *****
    过程式程序设计、结构化程序设计直到今天的面向对象程序设计

1.说一下你对面向对象的理解
    万物皆对象，面向对象是把具有相同特征的对象的属性定义成成员变量，
行为定义成成员方法。
    面向对象的三大特征是封装，继承，多态。
    面向对象的特性提高了大型程序的复用性和维护性
2.类和对象的关系
    类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间
3.面向过程和面向对象的区别
    1）面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能
    2）都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能
    3）面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势是明显
1.简述封装的设计原则，和好处 ***
    1）把成员变量用private修饰成私有的。
    2）给每个远程变量提供set和get方法。
    好处：通过封装，可以对类的属性进行隐藏。提高了代码的安全性，程序的可维护性增强。
2.private是干嘛的？怎么使用？
    private是一个权限修饰符，私有的，可以修饰类的成员。
    在成员前加上private，这个成员就只能在该类中访问。
3.this关键字的作用
    this指访问本类成员。可以用来解决成员变量和局部变量同名的情况。
1.static关键字的作用
    static是一个静态修饰符，可以修饰类的成员。
    被static修饰的静态成员，存放在内存中的静态区，随着类的加载而加载。
    用static修饰的成员，可以通过类名直接访问。格式为：类名.成员名。
    被static修饰的变量，是属于类的，不管对象有多少个，静态变量只有
    1份，只会被初始化一次。
2.main方法的原理是什么
    main方法是java程序的入口，程序永远从main的第一条有效语句开始执行。
        格式为：public static void main(String[] args){}
3.构造方法是什么，有什么用 ***
    构造方法就是与类的名字相同的方法，它没有返回值类型。
    作用：创建对象的时候对对象进行初始化。

1.什么是继承，为什么要使用继承
    继承是面向对象的三大特征之一，子类会继承父类所有的非私有成员，
构造方法除外。
    继承的实际意义在于可以提高代码的复用性。
2.继承条件下构造方法的执行过程
    1）子类在创建对象的时候，会调用构造方法，子类的构造方法在执行前，
系统会默认先调用父类的无参构造。
    2）如果子类显示的去调用父类的其它构造，就不会再默认调用无参构造。
3.继承需要注意什么，什么时候使用继承
    1）子类无法继承父类的私有成员。
    2）子类无法继承父类的构造方法。
    有两个类，当A是B类的一种时，使用继承。如：猫是动物，此时
猫类可以继承动物类。

1.方法重载和方法重写的区别(overload和override的区别) ***
    方法重载：在同一个类中，方法名相同，参数列表不同的方法间构成重载关系。
    方法重写：子类继承父类时，当子类中出现和父类相同的方法时，子类会
    重写父类的方法。

1.多态是什么？干什么用的 
    多态：同一个事物在不同时刻体现出的不同状态叫做多态。
    多态可以用父类用引用指向子类的对象，因为存在方法重写，所以
同一个父类引用调用同一个方法时可以体现出不同的效果。
    多态可以提高程序的复用性，可扩充性和维护性。
2.多态的技能点 ***
    1）前提：
    要有继承。
    要有方法重写。
    要有父类的引用指向子类的对象。
    2）向上转型
            将一个父类的引用指向一个子类对象，称为向上转型。
    3）向下转型
        将一个父类的引用强制转换成子类的引用，称为向下转型
3.多态的成员访问特点？ ***
    成员变量：编译看左边，运行看左边
成员方法：编译看左边，运行看右边
静态方法：编译看左边，运行看左边

1.什么是抽象类，抽象类有什么特点
    抽象类就是在类名前加了修饰符abstract。
一个类中有抽象方法，这个类必须为抽象类。
    抽象类不能实例化对象。
2.一个抽象类，如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？
  可以。定义为抽象类为了不让它实例化对象。
                                                        

1.访问修饰符的作用域都是什么样的？***
public作用于整个java项目
        protected可以作用于不同包的子类
        default(默认的) 作用于同一个包
        private作用于同一个类

static内部类：属于整个外部类，而不是属于外部类的每个对象。不能访问外部类的非静态成员（变量或者方法），.可以访问外部类的静态成员

面向对象的特征有哪些方面？
抽象、抽象是将一类对象的共同特征总结出来构造类的过程，包括数据抽象和行为抽象两 
方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。 
封装、通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义 
的接口。
继承、继承是从已有类得到继承信息创建新类的过程。被继承的类被称为父类；继承的类被称为子类
多态、多态性是指允许不同子类的对象对同一行为作出不同的响应。

接口和抽象类的区别
1、抽象类只能被单继承，但是接口可以多实现；
2、抽象类中有构造方法，接口中没有构造方法。
3、抽象类中即可以有普通成员变量也可以有常量；接口中变量全是常量，默认修饰符 public static final；
4、抽象类中既可以有抽象方法，也可以有普通方法，但是有有抽象方法的类必须定义为抽象类；接口中的方法只能定义为抽象方法，默认修饰符 public abstract。