黑马程序员技术交流社区

标题: 技术帖 [打印本页]

作者: JAVAEE-SAJ 时间: 2019-5-27 22:42
标题: 技术帖
1.数据类型
1. 计算机存储单元: 1B=8bit
2. 基本数据类型：数值型（整数型，浮点数型，字符型）非数值型（布尔型）
   byte 占用1bit,取值-128~127 ;int （默认）占4bit，21亿;
   short 占用2bit;  long 占用8bit;
   float 占4bit;  double （默认）占用8bit；
   char 占用2bit,0-65535； boolean 占用1bit, true,false;

2.变量
1. 定义格式：数据类型变量名 =数据值或常量值；
2. 注意事项：变量名不能重复；未赋值不能直接使用；long防止整数过大加L、float防止类型不兼容加F；

3.标识符
1. 给类，方法，变量起名字的符号
2. 由数字、字母、下划线_、美元符组成；不能以数字开头；不能是关键字；区分大小写；
3. 小驼峰命名（方法、变量）：标识符是一个单词时，首字母小写；多个单词，首字母小写，后几个单词首字母大写；
   大驼峰（类接口）：大写；

4.类型转换
1. 自动类型转换：把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量；
   等号左边的数据类型范围大于右边的；
   byte——short——int-long-float-double,byte不可自动转为char，类型不兼容;char-int-……
2. 强制：大转小；容易出现精度损失、数据溢出；
5. 基本逻辑运算符
            5.1  在java中，用来连接多个布尔类型结果的运算符；
与&  两个或多个布尔类型的数据值都是true为true
或|  全部布尔类型数据值都为false，结果为false
亦或^ 左右两边相同则为false,不同为true  true^true^false -->false^false =false;true^false^false  --> true^false =true
非! !true  !false

5.2  短路逻辑运算符：
短路与 && 全部为trye才为true
特点：遇到第一个false，后面的内容不再执行
短路或 || 全为false才为false
特点：遇到第一个true，后面不再执行

6. 三元运算符
            6.1 格式：关系表达式?表达式1:表达式2；
            关系表达式的值为true，运算结果是表达式1的值；
   …………………………………………false，……………………………………2…………；
            6.2 注意事项：运算结果必须被使用；表达式1、2的数据类型要与结果的变量的数据类型相同；

1. switch语句
1. 格式
switch(表达式(byte、short、int、char、枚举、（7之后）String)){
case 值1：          //后面跟的是要和表达式进行比较的值
      语句体1；
   break;       //表示中断，结束语句
      default:
      语句体n;    //顺序可随意变换
   break;
case 值2:
   语句体2；
   break;
2. case穿透：
case控制的语句体后面不写break;将出现穿透，不判断下一case值，直接运行下一语句，直到遇到break语句；
      1、2、12 冬季，只在case 12 处加打印冬季的语句；
case 1:
case 2:
case 12:
      System.out.println("冬季")
break;

switch(4){                                     switch(4){
default:                                     case 1:
      语句1                                        语句1
case 1:                                     case 2:
      语句2                                        语句2
case 2:                                     case 3:
      语句3                                        语句3
case 3:                                     default:
      语句4                                        语句4
      }                                              }
         可以正常走完，执行语句1、2、3、4。可以正常走完，执行语句4

2. for循环
1. 循环结构
初始化语句：（尽可能int i 从0开始）表示循环开始时的起始状态
条件判断语句：表示循环反复执行的条件
循环体语句：反复执行的内容
步进语句/条件控制语句：
2. 格式：
for(初始化语句；条件判断语句；步进语句/条件控制语句){
循环体语句；
   }
3. 执行流程
   1.执行初始化语句
   2.执行条件判断语句，看其结果是true或false
         如果是false，循环结束；
         如果是true,继续执行；
   3.执行循环体语句
   4.步进语句/条件控制语句
   5.回到2.

3. while(不知道循环次数，适合用while循环）
1. 格式：
   1. 基本格式：
   while (条件判断语句){
         循环体语句
   }
   完整格式：
   2. 初始化语句;
   while (条件判断语句){
   循环体语句
   步进语句/条件控制语句
   }
2. 执行流程
   1.执行初始化语句
   2.执行条件判断语句，看其结果是true或false
         如果是false，循环结束；
         如果是true,继续执行；
   3.执行循环体语句
   4.步进语句/条件控制语句
   5.回到2.

4. do while
1. 格式
   1.基本格式：
   do{
   循环体语句；}while(条件判断语句)；条件判断语句；
   2.完整格式：
   初始化语句
   do{
   循环体语句
   步进语句/条件控制语句
   }while(条件判断语句)；
   3. 执行流程
   1.执行初始化语句
   2.执行循环体语句
   3.执行条件判断语句，看其结果是true或false
         如果是false，循环结束；
         如果是true,继续执行；
   4.执行循环体语句
   5.步进语句/条件控制语句
   6.回到3.

5. 三种循环的区别
1. do while 第一次执行无论条件是否成立都会执行；

2. for 循环次数已经明确的情况下使用；

3. while 循环次数不明确

死循环：
while (true){
}
for(;;){
}

6. 跳转控制语句
1. continue 用在循环中，基于条件控制，跳过当前的循环体内容的执行（结束本次循环），继续下一次的执行；
2. break 直接跳出作用域范围内的循环；外部循环继续。

数组
1.定义格式
  1.1 数组概述：用于存储多个相同类型数据的存储模型。
  1.2 格式：//看到中括号，优先考虑是不是数组；
  (常用)1. 数据类型[] 变量名
         int[]  arr;
      2. 数据类型  变量名[]
         int    arr[];

2.数组初始化之动态初始化

  2.3 动态初始化
初始化时只指定数组长度，由系统为数组分配初始值;
长度指我们创建的数组里面存储几个具体的元素

数据类型[] 变量名=new 数据类型[数组长度];
int[] arr = int[5];
等号左边：
   int:数组的数据类型
   []:代表这是一个数组
   arr:代表数组的名称
等号右边：
   new:代表创建一个新的对象，（在内存里面申请一个新的空间保存数据）
   int:数组的数据类型
   []:代表这是一个数组
   5:代表数组的长度

   boolean[] b=new boolean[10];//用false占位
   String[] arr=new String[4];//引用数据类型用null占位；

   3. 数组元素的访问
         根据索引(下标)

3. 内存：
** 栈区 Stack：
      1.存储的都是局部变量
      2.方法执行的时候会进栈执行
** 堆区 Heap;
      new 出来的东西都在堆区里面
** 方法区
      加载字节码文件
   本地方法栈

   寄存器


   int[] arr=new int[]{1,2,3,4};
   int[] arr={1,2,3,a,b};


4. 数组操作的两个常见小问题
      1. 索引越界异常 ArrayIndexOutOfBoundsException
   索引arr[i] i>数组长度，出现错误。
   解决方法：将错误索引修改为正确的索引范围即可；

2. 空指针异常 NullPointerException
   int arr=new int[3];
   arr=null;
   变量arr不会保存在数组的堆内存地址，栈中的int arr[]地址指向空白
         解决方法：给数组一个真正的堆内存空间引用。
1. 方法概述
1.1 方法（method)是将具有独立功能的代码块组织成为一个整体，
使其具有特殊功能的代码集。
注意：**方法必须先创建才可以使用，该过程称为定义
      **方法创建后并不是直接运行，需要手动使用后才执行，该过程称为方法调用。

2. 方法定义和调用
2.1 定义：（写在main方法外）格式： public static void 方法名（）{
//方法体
}
2.2 调用：（写在main方法内）格式：方法名();
      必须定义以后调用。

2.3 方法调用过程
      总结：每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，
      方法内部代码调用完毕之后，会从栈内存中弹栈消失。

2.4 方法练习


3. 带参数方法的定义和调用
3.1 带参数方法定义
      格式：public static void 方法名(参数){……}

格式（单个参数）：public static void 方法名 (数据类型变量名）{……}
范例（单个参数）：public static void isEvenNumber(int number){……}

格式（多个参数）：public static void 方法名 (数据类型变量名1，数据类型变量名2，……）{……}
范例（多个参数）：public static void getMax(int number1, int number2){……}

注意：**方法定义时，参数中的数据类型与变量名都不可缺少，缺少任意一个程序将报错。
      **方法定义时，多个参数之间使用逗号（，）分隔。

3.2 带参数方法调用
      格式：  方法名（参数）;

格式（单个参数）：方法名 (变量名/常量值）;
范例（单个参数）：isEvenNumber(5);

格式（多个参数）：方法名 (变量名1/常量1，变量名2/常量2，……）;
范例（多个参数）：getMax(5, 6);

注意：方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则报错。

3.3 形参和实参
      形参：方法定义中的参数，等同于变量定义格式；
      实参：方法调用中的参数，等同于使用变量或常量；

3.4 带参数方法练习

4. 带返回值方法的定义和调用
4.1 带返回值方法定义
      格式：  public static 返回值数据类型  方法名（数据类型变量名，……）{
            return 具体返回值（常量/表达式）;
}
返回值类型主要

范例1： public static boolean isEvenNumber(int number){
      return true;
}
范例2： public static int getMax(int a,int b){
      return 100;
}
注意：
** 方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错。
***方法的形参类型和返回值类型无关，不需要一样

4.2 带返回值方法调用
      格式1(不常用）：方法名（参数）；
范例：isEvenNumber(5);

格式2：数据类型变量名=方法名（参数）；
范例：boolean flag=isEvenNumber(5);
注意：方法的返回值通常会用变量接受，否则结果无意义。
ctrl+alt+v 自动生成变量用于存储返回值。

***方法的返回值：表示方法运行所产生的结果，但是结果只能是一个。
** 方法的返回值通常会使用变量接收，否则该返回值将无意义。

5. 方法的注意事项
**方法不能嵌套定义
**void无返回值，可以省略return，也可以单独书写return,后面不加数据；
**（现阶段不在main方法之外调用其他方法）
**如果有返回值类型（不是void）都需要return表达式；

2. 方法通用格式
public static 返回值类型方法名（参数）{
方法体；
return 数据;
}
public static 修饰符，目前先记住这个格式
返回值类型方法操作完毕之后返回的数据的数据类型，如果方法操作完毕，
没有数据返回，这里写void，而且方法体中一般不写return
   方法名调用方法时候使用的标识
   参数由数据类型和变量名组成，多个参数之间用逗号隔开
   方法体完成功能的代码块
   return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
3. 注意事项：
***定义方法时，要做到两个明确
   - 明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
   - 明确参数：主要是明确参数的类型和数量
***调用方法时的注意：
   - void类型的方法，直接调用即可
   - 非void类型的方法，推荐用变量接收调用
6. 方法重载 OverLoad
方法重载指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载
1 条件：
      在同一个类中
方法名相同
方法参数的数据类型或个数或者顺序不同
2. 注意：
      ** 重载仅对应方法的定义，与方法的调用无关，调用方式参照标准格式
** 重载仅针对同一个类中方法的名称与参数进行识别，与返回值无关，
   换句话说不能通过返回值来判定两个方法是否相互构成重载

7. 方法的参数传递
1. 结论：
   对于基本数据类型作为方法参数，传递的是数据值（值传递）
   结论依据：
   每个方法在栈内存中，都会有独立的栈空间，方法运行结束后就会弹栈消失

2. 结论：
   对于引用类型的参数，形式参数的改变，影响实际参数的值
   结论依据：
   引用数据类型的传参，传入的是地址值，内存中会造成两个引用指向同一个内存的效果，
   所以即使方法弹栈，堆内存中的数据也已经是改变后的结果

2. 类
2.1 类的理解
* 类是对现实生活中一类具有共同属性和行为的事物的抽象
* 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
* 简单理解：类就是对现实事物的一种描述

* 类的组成
* 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
* 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
* 类和对象的关系
* 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
* 对象：是能够看得到摸的着的真实存在的实体


2.2 类的创建：
1. 类的定义:

类的组成是由属性和行为两部分组成

* 属性：在类中通过成员变量来体现（类中方法外的变量）
* 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

2. 格式：
      public class 类名{
//1. 成员变量
int age;(定义成员变量不需要初始化值）
      数据类型  变量名；

//2. 成员方法
public void show(){

}
}

      public class Student(){
String name;
int age;
String grender;
public void eat(){
}
public void drink(){
}
public void play(){
}
public void happy(){
}
}

   3. 创建对象
       * 创建对象的格式：
   * 类名对象名 = new 类名();
   * 调用成员的格式：
   * 对象名.成员变量
   * 对象名.成员方法();
   * 示例代码

      public class StudentTest(){
public static void main(){

Student s=new Student();

System.out.println(s.age);
System.out.println(s.name);
System.out.println(s.grender);

s.age=18;
s.name="张三";
s.grender="男";

System.out.println(s.age);
System.out.println(s.name);
System.out.println(s.grender);

s.eat();
s.drink();
s.play();
s.happy();
}
}

      调用成员方法，在方法区找到对应方法，进栈操作。运行完出栈销毁

3. 成员变量和局部变量

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

- 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
- 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
- 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
- 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

public class Student(){
      private String name;
   private int age;

   public void getName(){
   return name;
   }

      public String setName(String n){
         name=n;
   }

      public void getAge(){
         return age;
   }

   public int setAge(int a){
   age=a;
   }

   public void show(){
   System.out.println(name+","+age);
   }
}

public class StudentDemo(){
public static void main(String[] args){
Student s=new Student();
s.setName("张三");
s.setAge(18);
s.show();
System.out.println(s.getAge()+","+s.getName())
}
}

4. 封装

   4.1 private关键字

      private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

      * 被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
      * 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
      * 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

   4.2 private的使用

      * 需求：定义标准的学生类，要求name和age使用private修饰，
并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出
      封装最主要好处：提高代码安全性

   4.3 this关键字

   -this  使用位置：在成员方法里；
      修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
   -方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
   -方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量
      成员方法中的this指的是调用该方法的对象。（s.setAge调用了setAge方法，Student类中的成员方法setAge中，
      this.age=age,this指的就是s,与s的地址值相同。

   4.5 封装思想

   1. 封装概述
      是面向对象三大特征之一（封装，继承，多态）
      是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
   2. 封装原则
      将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
      成员变量private，提供对应的getXxx()/setXxx()方法
   3. 封装好处
      通过方法来控制成员变量的操作，提高了代码的安全性
      把代码用方法进行封装，提高了代码的复用性

5. 构造方法
   构造方法是一种特殊的方法

* 构造方法的创建
      如果没有定义构造方法，系统将给出一个默认的无参数构造方法
      如果定义了构造方法，系统将不再提供默认的构造方法

      * 构造方法的重载
如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

* 推荐的使用方式
      无论是否使用，都手工书写无参数构造方法

1. 功能：创建对象使用,可以使用带参构造，为成员变量进行初始化
2. 格式：
   public 类名（参数列表）{
   方法体；
   }
   调用： new 类名（参数列表）；


一个标准的类（JavaBean）包括：
   1. 用private修饰类成员；
   2. 无参，全参的构造方法
   3. Setter,Getter方法。

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2