黑马程序员技术交流社区

标题: 基础 [打印本页]

作者: 凡凡 时间: 2019-4-30 10:28
标题: 基础
## 1_变量

- 计算机采用变量来存储信息,变量类似一个盒子,盒子里面可以存储信息. 盒子有标签和内容, 变量也一样.
- 定义变量的格式:
  - 数据类型变量名 = 值;
int num;
int[] nums;
String name;
HashMap<String,String> map;
Itheima it;

## 2_变量名标签

- 变量名是一个单词或者是一组单词,用来描述一个数据的含义,方便人理解,变量名不能有空格.
- 关键字
  - 概述: Java中具有特殊含义的单词,关键字都是小写的.
- 标识符:
  - 概述: 就是用来给变量,类,接口,方法起名字用的.
  - 命名规则:
- a. 不能和Java中的关键字重名.
- b. 只能由数字,字母,_或者$组成,不能以数字开头.
- c. 严格区分大小写.
- d. 最好做到见名知意.
  - 命名规范:
- 常量:所有字母都大写,字母之间用符号_隔开.
   - MAX_VALUE, MIN_VALUE
- 变量,方法:从第二个单词开始,所有单词的首字母都大写,其他字母都小写.
   - getSum,maxValue
- 类,接口:所有单词的首字母都大写,其他子母小写.
   - StudentMessage,HelloWorld,ForDemo
- 包:所有字母都小写,包名之间用符号.隔开.
   - com.itheima.test, com.tankwar.app

## 3_变量可以修改数据

- 变量的值可以覆盖.
- 格式:
  - 变量名 = 值;  //这行代码一般写在方法中.

## 4_数据类型

- 数据有很多种不同的类型, 最常见的有数字类型和字符串类型.
- 常见的数据类型:
  - int类型  (整型)
- long    (长整型)
  - double  (浮点型,小数类型)
  - String  (字符串类型)

## 5_整数和小数

- 常见的数据类型:
  - 字符串类型
- String, 值用""括起来
  - 整型
- byte
- short
- int
- long, 值后边要加上字母L(大小写均可)
  - 浮点型
- float, 值后边要加上字母F(大小写均可)
- double
  - 字符型
- char, 值用''括起来
  - 布尔类型
- boolean, 值只能是true或者false.

## 6_字符串相加

- 猜猜看,下面代码的运行结果是什么:

  - 代码示例

<pre>
String firstName = "Tomas";
      String familyName = "Zhang";
打印 firstName + familyName 的结果是什么;
   </pre>

- 字符串相加,会直接拼接, 得到一个新的字符串.

## 7_变量的使用和赋值

- 变量没有赋值就不能使用? 对么?

  - 对的. 使用变量必须先声明, 再赋值, 然后才能使用.

- 示例代码

  <pre>
  public class Itheima{
    int weight;
    public void test(){
    int age;
    System.out.println(age);    //局部变量,没有默认值.
    System.out.println(weight); //成员变量,有默认值.
    }
  }
  </pre>

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

  - 局部变量: 没有默认初始化值, 想使用必须先声明, 再赋值, 然后才能使用.
  - 成员变量: 有默认初始化值, 例如:
- String类型默认值是 null,
- 整数类型默认值是 0,
- 浮点类型默认值是 0.0,
- 布尔类型默认值是 false.
-

## 8_加加和减减

- 算术运算符
  - +, -, *, /, %, ++, --
- ++和--的用法(此处以++为例)
  - 单独使用
- 前加后加没有区别, 都是自身+1.
  - 参与运算
- 前加: 先自身+1, 然后用新值来运算.
- 后加: 先以原值来运算, 然后再自身+1.

## 9_加等于和减等于

- 赋值运算符

  - +=, -=, *=, /=, %=, =

- 赋值运算符的用法(此处以+=举例)

  - +=: 左边和右边相加, 并把结果赋值给左边.

- 比较运算符:

  - > =  //大于或者等于

  - <=  //小于或者等于

  - > //大于

  - < //小于

  - ==  //等于

  - !=  //不等于

- 逻辑运算符

  - && 逻辑与, 要求条件都必须满足, 如果有false, 则整体为false. //相当于: And
  - || 逻辑或, 只要满足一个条件就行, 如果有true, 则整体为true. //相当于: Or
  - !  逻辑非, 取反操作, 以前为false, 现在为true, 以前为true, 现在为false. //相当于: No


## 10_if结构

```
1.
if(条件语句){
// 任意的代码条件成立,就会执行,条件不成立,就不会执行

}
```

```
2.
if(条件){

// 条件成立,就会执行的代码 1
}else{

// 条件不成立,就会执行的代码 2
}

// 所以代码1 和代码2 不会同时执行,也不会同时不执行

3.
if(条件1){
// 代码1

}else if(条件2){
// 代码2

}else if(条件3){
// 代码3

}else{
// 代码4

}
```

## 11_注释

概述: 注释就是用来解释代码的, 大白话, 就是给人看的.

```
分类:
单行注释:ctrl+/
// 注释的文字
多行注释:  ctrl+shift + /
/*
注释的文字
*/
文档注释:
/**
注释的文字
*/
```

## 12_数组

概述: 数组就是一个容器,可以存储多个相同类型的数据 ,数组的长度是固定的

语法:
1. 先声明,后初始化
声明: 数据类型[] 数组名;
String[] names;

```
初始化: 数组名 = new 数据类型[长度];
names = new String[4];

2.声明的同时初始化
数据类型[] 数组名 = new 数据类型[长度];  // 常用  推荐
String[] names = new String[4];
```

```
String name;
name = "jack";

String name = "jack";

3.快速初始化数组
数据类型[] 数组名 = {值1,值2,值3,...}; // 推荐
String[] names = {"张三","李四","王五","赵六"};

数据类型[] 数组名 = new 数据类型[]{值1,值2,值3,...};// 常见
String[] names = new String[]{"张三","李四","王五","赵六"};

赋值:
数组名[索引] = 值;
names[0] = "班长";

取值:
数组名[索引]

特点:
索引: 索引是从0开始的 ,最大的索引是 : 数组长度-1
长度:数组的长度是数组的一个属性 int len = 数组名.length;
```

```
注意: 数组越界(索引越界)
```

## 13_字符串

String类：
作用：代表字符串，里边也定义了一些对字符串的常见操作。
//理解: 字符串的底层其实是一个字符数组。
常用的构造方法：
public String();
public String(String str);
public String(char[] chs);

```
常用的方法：
concat();  //把两个字符串拼接起来，获取一个新的字符串
★length();  //获取字符串的长度(其实就是获取字符串中字符的个数)
★isEmpty(); //判断字符串是否为空(长度为0返回true，不为0返回false)
★equals();  //比较两个字符串的内容是否相同。 //区分大小写
equalsIgnoreCase();  //比较两个字符串的内容是否相同。 //忽略大小写
★charAt(); //根据给定的索引，获取对应位置的字符
★contains(); //判断字符串中是否包含给定的字符串。
endsWith(); //判断字符串是否以给定的字符串结尾。
startsWith(); //判断字符串是否以给定的字符串开头。
★indexOf(); //获取指定的字符在字符串中第一次出现的位置(索引)，找不到返回-1
//int index = a1.indexOf('h'); 从头找，'h'第一次出现的位置
//int index = a1.indexOf('h',3); 从索引为3的元素开始往后找，'h'第一次出现的位置
lastIndexOf(); //获取指定的字符在字符串中最后一次出现的位置(索引)，找不到返回-1
//int index = a1.lastIndexOf('h'); 从尾部找，'h'最后一次出现的位置
//int index = a1.lastIndexOf('h',3); 从索引为3的元素开始往前找，'h'最后一次出现的位置
★replace(); //用新内容替代旧内容，返回新的字符串
★split(); //根据给定的内容，切割字符串，返回字符串数组
★substring(); //截取字符串，返回新的字符串
//String newStr = a1.substring(2);       //从给定索引，直接截取到字符串末尾
//String newStr = a1.substring(2,5);    //包左不包右(前闭后开), 能取索引2的元素，不能取索引5的元素
toLowerCase(); //把字母都转成其对应的小写形式。
toUpperCase(); //把字母都转成其对应的大写形式。
★trim(); //移除首尾空格。 " abc "-->"abc"

理解的口诀:
判断功能：  首尾中空加判断

获取功能: 截长取位取元素

转换功能：大小拼串转数组
//toCharArray(), getBytes();
其他功能：  除空切换字典拍
//copareTo();
```

## 18_面向对象入门

面向对象入门(封装):
Java语言就是用来描述现实世界事物的, 最基本的单位是类.
   * 如何定义类
   * 格式
   public class 类名 {
   }
   * 注意
   * 类名要和文件名一致

```
类与对象的关系:
类: 一个抽象的概念,是看不见也摸不着的
对象: 类的具体体现,实现.
属性: 名词, 事物有哪些特征.
//其实就是我们说的: 成员变量
行为: 动词, 事物能做什么
//其实就是我们说的: 成员方法

如何创建对象:
数据类型对象名 = new 数据类型();
如何使用类中的内容(成员)
通过对象点的形式来调用.

构造方法:
作用: 用来创建对象的.
//大白话: 其实就是用来给属性赋值的.
格式:
public 类名(参数列表) {
}

封装:
概述: 隐藏对象的属性和实现细节,仅对外提供一个公共的访问方式.
如何隐藏?
可以通过 private 关键字实现.
private 关键字:
被它修饰的内容,只能在本类中直接访问.
公共的访问方式是什么?
getXxx() 和 setXxx()
```

## 20_this关键字讲解

- 概述:
  - 官方解释: 代表本类当前对象的引用.
  - 大白话: 谁调用, 就代表谁.
- 作用:
  - 用来解决局部变量和成员变量重名问题的.
- 局部变量和成员变量的区别:
  - 局部变量: 定义在方法中, 或者方法声明上的变量, 没有默认值.
  - 成员变量: 定义在类中, 方法外的变量, 有默认值.
- 记忆:
  - Java中使用变量遵循的特点: 遵循就近原则.
  - 局部有就使用, 没有就去本类的成员位置找, 有就使用, 没有就报错. //先这么记忆, 不严谨.

## 21_static关键字

- 概述:
  - 当一个属性是被该类下所有的对象所共享的时候, 就可以考虑使用静态.
- 特点:
  - a. 被static修饰的内容, 能被该类下所有的对象所共享.
- b. 可以被类名点的形式直接调用. //记忆
- 注意事项:
  - a. 静态方法中是没有 this 关键字.
  - b. 静态方法中只能直接访问静态.


## 23_Random类讲解

- 关于是否导包:
  - 如果是使用java.lang包下的类, 是可以直接使用的, 不用导包.
  - 其他包下的类, 必须导包才能使用.
- Random类中的成员方法:
  - public int nextInt(int n); 生成一个0~n之间的随机数, 包左不包右

## 24_while循环

- loop是神奇的东西, 允许我们让计算机执行代码任意的次数.

- while循环, 后跟一个条件, 重复执行任务只要条件为真.

- 尝试运行下面的代码

  - 创建Itheima类, 创建无参无返回值test方法

<pre>
int counter = 0;
while(counter < 10) {
counter++;
}
System.out.print(counter);
</pre>

- while循环

  - 语法格式:

<pre>
初始化条件;    //1
while(判断条件) { //2
//循环体 //3
//控制条件 //4
}
</pre>

  - 执行顺序:

- 第一次执行:
   - 先执行初始化条件, 在执行判断条件, 如果不成立, 就结束
   - 如果成立, 就执行循环体, 然后执行控制条件.
- 第二次执行:
   - 执行判断条件, 再执行循环体, 在执行控制条件
- .....(重复第二次步骤)
- 最后一次:
   - 执行判断条件, 不成立, 循环结束.

  - 用1,2,3,4步来陈述上述的执行流程:

- 第一次执行: 1, 2, 3, 4
   - 第二次执行: 2, 3, 4
      第三次执行: 2, 3, 4
      ........ 2, 3, 4
- 最后一次执行: 2

## 25_do.while循环

- do while循环和while循环,基本上类似, 不过do while循环是先干活, 后检查条件是否成立

- 尝试运行下面的代码

  - 创建Itheima类, 创建无参无返回值test方法

<pre>
int counter = 5;
do{
      counter++;
}while(counter<10);
System.out.print(counter);
</pre>

- do.while循环

  - 语法格式:

<pre>
初始化条件; //1
do {
//循环体 //3
//控制条件 //4
}while(判断条件) ; //2
</pre>

  - 执行顺序:用1,2,3,4步来陈述上述的执行流程:

- 第一次: 1, 3, 4, 2
   - 第二次: 3, 4, 2
      ...... 3, 4, 2
- 最后一次: 2

## 26_for循环

- for循环

  - 包含三个部分, 第一部分,循环的开始条件,第二部分循环的判断条件,第三部分循环的的变化方式.

- 尝试运行下面的代码

  - 创建Itheima类, 创建无参无返回值test方法

<pre>
for(int i =1;i<=8;i++){
      System.out.println(i);
}
</pre>

- for循环

  - 语法格式:

<pre>
// 1    2    4
for(初始化条件; 判断条件; 控制条件) {
//循环体 //3
}
</pre>

  - 执行顺序:

- 第一次执行:
   - 先执行初始化条件, 在执行判断条件, 如果不成立, 就结束
   - 如果成立, 就执行循环体, 然后执行控制条件.
- 第二次执行:
   - 执行判断条件, 再执行循环体, 在执行控制条件
- .....(重复第二次步骤)
- 最后一次:
   - 执行判断条件, 不成立, 循环结束.

  - 用1,2,3,4步来陈述上述的执行流程:

- 第一次执行: 1, 2, 3, 4
   - 第二次执行: 2, 3, 4
      第三次执行: 2, 3, 4
      ........ 2, 3, 4
- 最后一次执行: 2

## 27_for循环倒序输出

- 尝试运行下面的代码

  - 创建Itheima类, 创建无参无返回值test方法

  - 我们来看看另外一种for循环的写法

<pre>
for(int i=5 ;i>0;i--){
      System.out.println(i);
}
</pre>

## 28_三种循环之间的区别

- 需求:
  - 到目前为止, 我们学过的循环有: while, do.while, for
- 和循环相关的一些问题:
  - 问题一: 什么时候使用哪种循环?
- 循环次数已知吗?
   - 是: for
   - 否: //一般我们会优先选择while
      - 是否需要先执行一次,再判断:
      - 是: do.while
      - 否: while
  - 问题二: 三种循环之间的区别是什么?
- do.while循环和其他两种循环的区别:
   - do.while循环是先执行一次后判断, 其他两个循环是先判断, 后决定是否执行.
   - for循环和其他两个循环的区别: for循环执行完毕后, 初始化条件就不能用了, 其他两个循环执行完毕后, 初始化条件还可以继续使用.
   - 这个就是我理解的这个问题.

## 29_泛型和包装类

- 泛型
  - 概述: 泛指某种特定的数据类型, 表示形式为: <>
- 大白话: 泛型就是用来确定, 集合中将要添加什么类型的数据.
  - 好处:
- 提高代码的安全性.
  - 记忆:
- 泛型只能是引用数据类型.
- 泛型一般只和集合结合使用.
- 包装类:
  - 概述:
- 其实就是基本数据对应的引用数据类型.
  - 各基本类型对应的包装类如下:
- 基本数据类型对应的引用数据类型(包装类)
   - byte       Byte
      short Short
      char Character
      int Integer
      long Long
      float float
      double Double
      boolean Boolean
  - 自动拆装箱(JDK1.5的新特性)
- 自动装箱: 就是把基本类型的数据转成对应的引用数据类型.
   - Integer i = 10;
- 自动拆箱: 就是把引用类型的数据转成对应的基本数据类型.
   - Integer i = 10;
   - int a = i;

## 30.ArrayList集合

```
ArrayList: 有序,可重复
add(Object value);    //添加元素
get(int index);    //根据索引获取对应的元素.
set(int index,Object value); //把指定索引位置改成指定值
remove(int index); //根据索引移除元素
isEmpty(); //判断集合是否为空
indexOf(); //返回指定元素在集合中第一次出现的位置, 如果元素不存在,返回-1
lastIndexOf(); //返回指定元素在集合中最后一次出现的位置, 如果元素不存在,返回-1
size(); //获取集合的长度(元素的个数)
toArray(); //把集合转成对应的数组
//Arrays.toString(数组对象); //把数组转成其对应的字符串形式(快速打印数组的内容)
```

# 32_抽象类

- 概述:
  - 有抽象方法的类一定是抽象类(或者接口), 抽象类中不一定有抽象方法.
- 特点:
  - 1.有抽象方法的类一定是抽象类(或者接口), 抽象用关键字 abstract 修饰.
  - 2.抽象类能创建对象吗?
- 不能.
- 既然抽象类不能实例化, 那么怎么实例化呢?
   - 可以通过创建其子类对象, 完成实例化.
   - 多态:  Animal an = new Cat();
  - 3.抽象类有构造方法吗?
- 有.
- 既然不能创建对象, 那么要构造方法有什么用?
   - 用于子类对象访问父类数据前,对父类数据进行初始化.
  - 4.抽象类的子类:
- 要么也是抽象类: 这样可以不用重写抽象方法.
   - 要么是普通类: 必须重写父类中的所有抽象方法.

## 33_不能和abstract共存的关键字有哪些(面试题)

- 不能和 abstract 关键字共存的关键字有哪些?
  - static: 静态方法可以被类名点的形式调用, 但是抽象方法是没有方法体的, 这样做没有意义, 所以不能同存.
  - private: 表示私有的意思, 被它修饰的方法不能被子类重写, 但是抽象方法要求子类必须重写, 所以属于设计冲突.
  - final: 表示最终的意思, 被它修饰的方法不能被子类重写, 但是抽象方法要求子类必须重写, 所以属于设计冲突.

## 34_接口

- 概述:

  - 比抽象类更加抽象.
  - 接口不是类, 因为接口中没有构造方法.

- 特点:

  - 1. 接口用 interface 关键字表示.

  - 1. 类实现接口用 implements 关键字表示.

  - 1. 接口中没有构造方法的.

  - 1. 接口的子类:

- 要么也是抽象类: 这样可以不用重写抽象方法.
   - 要么是普通类: 必须重写父接口中的所有抽象方法.

- 接口的成员特点:

  - JDK1.7及其以前:
- 接口中的成员有且只能有: 抽象方法或者是常量.
- 抽象方法的默认修饰符: public abstract
- 常量的默认修饰符: public static final
  - JDK1.8之后:
- 接口中可以定义有方法体的方法了,
- 如果是静态可以直接写, 如果是非静态方法, 必须加default.

## 35_类与接口之间的关系

- 类与接口之间的关系:
  - 类与类: 继承关系, 只能单继承, 不能多继承, 但是可以多层继承.
  - 类与接口: 实现关系, 可以单实现, 可以多实现, 还可以在继承一个类的同时实现多个接口.
  - 接口与接口: 继承关系, 可以单继承,也可以多继承.
- 面试题:
  - 抽象类和接口的区别是什么:
- 1.成员特点不同
   - 抽象类中的成员比普通类多一种抽象方法(而且抽象方法也可以不写)
   - 接口中有且只能有抽象方法(JDK1.8以后可以有带方法体的方法)或者常量.
- 2.关系特点不同
   - 参考上个知识点
- 3.设计理念不同
   - 抽象类: 定义的是整个继承体系的共性内容.
   - 接口: 定义的是整个继承体系的扩展内容.
- 记忆:
  - 以后我们学习一个新的体系, 都将采用: 学顶层, 用底层的方式.
  - 因为顶层记录的是整个体系的共性内容, 而底层才是具体的实现.

## 36_多态

- 概述:
  - 同一事物在不同时刻表现出来的不同形态(状态).
- 前提条件:
  - 1.必须要有继承(或者实现)关系.
  - 2.要有父类(父接口)引用指向子类对象.
  - 3.要有方法重写.

## 37_多态的访问特点

- 多态的访问特点:
  - 成员变量:
- 编译看左边, 运行看左边.
  - 成员方法:
- 静态: 编译看左边, 运行看左边.
- 非静态: 编译看左边, 运行看右边.
  - 总结: (记忆)
- 只有非静态方法是编译看左边,运行看右边, 其他都是编译和运行都看左边.
- 原因是因为: 只有非静态方法有方法重写.

## 38_多态的好处和弊端

- 多态的好处

  - 1.提高代码的扩展性.
  - 2.提高代码的可维护性.

- 多态在实际开发中最常用的应用场景:

  - 父类型可以作为方法的形参的参数类型, 这样可以接受其任意的子类对象.

  - 代码示例:

<pre>
public static void test(Person p) {
p.eat();
}
</pre>

- 多态的弊端:

  - 父类(父接口)引用不能直接使用子类的特有成员(成员变量和成员方法).
  - 怎么解决这个问题呢?
- 可以通过向下转型实现.

- 向上转型和向下转型: 这个概念是针对于引用类型的

  - Person person = new Student(); 向上转型
- Student s = (Student)person; 向下转型

- 隐式类型转换和强制类型转换: 这个概念是针对于基本类型的

  - double d = 10; 隐式类型转换
- int a = (int)d; 强制类型转换

作者: 白龙马有点黑 时间: 2019-5-6 20:20
故天将降大任于斯人也，必先苦其心志，劳其筋骨，饿其体肤，空乏其身，行拂乱其所为，所以动心忍性，曾益其所不能。

作者: 唐雨忆 时间: 2019-5-6 20:35
在醒着的时间里，追求你认为最有意义的。

作者: 雨后那道光 时间: 2019-5-8 11:39

财富是一时的朋友，而朋友才是永久的财富；荣誉是一时的荣耀，做人才是永久的根本；学历是一时的知识，学习才是永久的智慧！

作者: 小逗比 时间: 2019-5-8 11:56
你有多努力，就有多特殊。人只有坚持把自己变好，就真的会越来越好。

作者: 一只小熊猫 时间: 2019-5-8 12:36

昨天是一张作废的支票，明天是一张期票，而今天则是唯一拥有的现金。

作者: yuanfang123 时间: 2019-5-8 13:16

并不是因为肩上的包袱太重，而让我们扛不住；而是我们太在意别人的看法，而失去了继续扛下去的勇气。

作者: 188杨 时间: 2019-5-8 16:41
奋斗不一定能带来成功，但是一定能带来成长。

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

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