这些都是java中的基础,难度不高,就是多练.
变量
- 计算机采用变量来存储信息,变量类似一个盒子,盒子里面可以存储信息. 盒子有标签和内容, 变量也一样.
- 定义变量的格式:
- 数据类型 变量名 = 值;
int num;
int[] nums;
String name;
HashMap<String,String> map;
Itheima it;
- 数据类型 变量名 = 值;
变量名标签
- 变量名是一个单词或者是一组单词,用来描述一个数据的含义,方便人理解,变量名不能有空格.
- 关键字
- 概述: Java中具有特殊含义的单词,关键字都是小写的.
- 标识符:
- 概述: 就是用来给变量,类,接口,方法起名字用的.
- 命名规则:
- a. 不能和Java中的关键字重名.
- b. 只能由数字,字母,_或者$组成,不能以数字开头.
- c. 严格区分大小写.
- d. 最好做到见名知意.
- 命名规范:
- 常量:所有字母都大写,字母之间用符号_隔开.
- MAX_VALUE, MIN_VALUE
- 变量,方法:从第二个单词开始,所有单词的首字母都大写,其他字母都小写.
- getSum,maxValue
- 类,接口:所有单词的首字母都大写,其他子母小写.
- StudentMessage,HelloWorld,ForDemo
- 包:所有字母都小写,包名之间用符号.隔开.
- com.itheima.test, com.tankwar.app
- 常量:所有字母都大写,字母之间用符号_隔开.
变量可以修改数据
- 变量的值可以覆盖.
- 格式:
- 变量名 = 值; //这行代码一般写在方法中.
数据类型
- 数据有很多种不同的类型, 最常见的有数字类型和字符串类型.
- 常见的数据类型:
- int类型 (整型)
- long (长整型)
- double (浮点型,小数类型)
- String (字符串类型)
- int类型 (整型)
整数和小数
- 常见的数据类型:
- 字符串类型
- String, 值用""括起来
- 整型
- byte
- short
- int
- long, 值后边要加上字母L(大小写均可)
- 浮点型
- float, 值后边要加上字母F(大小写均可)
- double
- 字符型
- char, 值用’'括起来
- 布尔类型
- boolean, 值只能是true或者false.
- 字符串类型
字符串相加
- 猜猜看,下面代码的运行结果是什么:
- 代码示例
String firstName = "Tomas"; String familyName = "Zhang"; 打印 firstName + familyName 的结果是什么;
- 代码示例
- 字符串相加,会直接拼接, 得到一个新的字符串.
变量的使用和赋值
-
变量没有赋值就不能使用? 对么?
- 对的. 使用变量必须先声明, 再赋值, 然后才能使用.
-
示例代码
public class Itheima{ int weight; public void test(){ int age; System.out.println(age); //局部变量,没有默认值. System.out.println(weight); //成员变量,有默认值. } } -
局部变量和成员变量的区别:
- 局部变量: 没有默认初始化值, 想使用必须先声明, 再赋值, 然后才能使用.
- 成员变量: 有默认初始化值, 例如:
- String类型默认值是 null,
- 整数类型默认值是 0,
- 浮点类型默认值是 0.0,
- 布尔类型默认值是 false.
加加和减减
- 算术运算符
- +, -, *, /, %, ++, –
- ++和–的用法(此处以++为例)
- 单独使用
- 前加后加没有区别, 都是自身+1.
- 参与运算
- 前加: 先自身+1, 然后用新值来运算.
- 后加: 先以原值来运算, 然后再自身+1.
- 单独使用
加等于和减等于
-
赋值运算符
- +=, -=, *=, /=, %=, =
-
赋值运算符的用法(此处以+=举例)
- +=: 左边和右边相加, 并把结果赋值给左边.
-
比较运算符:
-
= //大于或者等于
- <= //小于或者等于
-
//大于
- < //小于
- == //等于
- != //不等于
-
-
逻辑运算符
- && 逻辑与, 要求条件都必须满足, 如果有false, 则整体为false. //相当于: And
- || 逻辑或, 只要满足一个条件就行, 如果有true, 则整体为true. //相当于: Or
- ! 逻辑非, 取反操作, 以前为false, 现在为true, 以前为true, 现在为false. //相当于: No
if结构
1.
if(条件语句){
// 任意的代码 条件成立,就会执行,条件不成立,就不会执行
}
2.
if(条件){
// 条件成立,就会执行的代码 1
}else{
// 条件不成立,就会执行的代码 2
}
// 所以代码1 和代码2 不会同时执行,也不会同时不执行
3.
if(条件1){
// 代码1
}else if(条件2){
// 代码2
}else if(条件3){
// 代码3
}else{
// 代码4
}
注释
概述: 注释就是用来解释代码的, 大白话, 就是给人看的.
分类:
单行注释:ctrl+/
// 注释的文字
多行注释: ctrl+shift + /
/*
注释的文字
*/
文档注释:
/**
注释的文字
*/
数组
概述: 数组就是一个容器,可以存储多个相同类型的数据 ,数组的长度是固定的
语法:
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;
注意: 数组越界(索引越界)
字符串
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();
面向对象入门
面向对象入门(封装):
Java语言就是用来描述 现实世界事物的, 最基本的单位是类.
* 如何定义类
* 格式
public class 类名 {
}
* 注意
* 类名要和文件名一致
类与对象的关系:
类: 一个抽象的概念,是看不见也摸不着的
对象: 类的具体体现,实现.
属性: 名词, 事物有哪些特征.
//其实就是我们说的: 成员变量
行为: 动词, 事物能做什么
//其实就是我们说的: 成员方法
如何创建对象:
数据类型 对象名 = new 数据类型();
如何使用类中的内容(成员)
通过 对象点 的形式来调用.
构造方法:
作用: 用来创建对象的.
//大白话: 其实就是用来给属性赋值的.
格式:
public 类名(参数列表) {
}
封装:
概述: 隐藏对象的属性和实现细节,仅对外提供一个公共的访问方式.
如何隐藏?
可以通过 private 关键字实现.
private 关键字:
被它修饰的内容,只能在本类中直接访问.
公共的访问方式是什么?
getXxx() 和 setXxx()
this关键字讲解
- 概述:
- 官方解释: 代表本类当前对象的引用.
- 大白话: 谁调用, 就代表谁.
- 作用:
- 用来解决 局部变量 和 成员变量 重名问题的.
- 局部变量和成员变量的区别:
- 局部变量: 定义在方法中, 或者方法声明上的变量, 没有默认值.
- 成员变量: 定义在类中, 方法外的变量, 有默认值.
- 记忆:
- Java中使用变量遵循的特点: 遵循就近原则.
- 局部有就使用, 没有就去本类的成员位置找, 有就使用, 没有就报错. //先这么记忆, 不严谨.
static关键字
- 概述:
- 当一个属性是被该类下所有的对象所共享的时候, 就可以考虑使用静态.
- 特点:
- a. 被static修饰的内容, 能被该类下所有的对象所共享.
- b. 可以被 类名点 的形式直接调用. //记忆
- a. 被static修饰的内容, 能被该类下所有的对象所共享.
- 注意事项:
- a. 静态方法中是没有 this 关键字.
- b. 静态方法中只能直接访问静态.
Random类讲解
- 关于是否导包:
- 如果是使用java.lang包下的类, 是可以直接使用的, 不用导包.
- 其他包下的类, 必须导包才能使用.
- Random类中的成员方法:
- public int nextInt(int n); 生成一个0~n之间的随机数, 包左不包右
while循环
- loop是神奇的东西, 允许我们让计算机执行代码任意的次数.
- while循环, 后跟一个条件, 重复执行任务只要条件为真.
- 尝试运行下面的代码
- 创建Itheima类, 创建无参无返回值test方法
int counter = 0; while(counter < 10) { counter++; } System.out.print(counter);
- 创建Itheima类, 创建无参无返回值test方法
- while循环
- 语法格式:
初始化条件; //1 while(判断条件) { //2 //循环体 //3 //控制条件 //4 } - 执行顺序:
- 第一次执行:
- 先执行初始化条件, 在执行判断条件, 如果不成立, 就结束
- 如果成立, 就执行循环体, 然后执行控制条件.
- 第二次执行:
- 执行判断条件, 再执行循环体, 在执行控制条件
- …(重复第二次步骤)
- 最后一次:
- 执行判断条件, 不成立, 循环结束.
- 第一次执行:
- 用1,2,3,4步来陈述上述的执行流程:
- 第一次执行: 1, 2, 3, 4
- 第二次执行: 2, 3, 4
第三次执行: 2, 3, 4
… 2, 3, 4
- 第二次执行: 2, 3, 4
- 最后一次执行: 2
- 第一次执行: 1, 2, 3, 4
- 语法格式:
do.while循环
- do while循环和while循环,基本上类似, 不过do while循环是先干活, 后检查条件是否成立
- 尝试运行下面的代码
- 创建Itheima类, 创建无参无返回值test方法
int counter = 5; do{ counter++; }while(counter<10); System.out.print(counter);
- 创建Itheima类, 创建无参无返回值test方法
- do.while循环
- 语法格式:
初始化条件; //1 do { //循环体 //3 //控制条件 //4 }while(判断条件) ; //2 - 执行顺序:用1,2,3,4步来陈述上述的执行流程:
- 第一次: 1, 3, 4, 2
- 第二次: 3, 4, 2
… 3, 4, 2
- 第二次: 3, 4, 2
- 最后一次: 2
- 第一次: 1, 3, 4, 2
- 语法格式:
for循环
- for循环
- 包含三个部分, 第一部分,循环的开始条件,第二部分循环的判断条件,第三部分循环的的变化方式.
- 尝试运行下面的代码
- 创建Itheima类, 创建无参无返回值test方法
for(int i =1;i<=8;i++){ System.out.println(i); }
- 创建Itheima类, 创建无参无返回值test方法
- for循环
- 语法格式:
// 1 2 4 for(初始化条件; 判断条件; 控制条件) { //循环体 //3 } - 执行顺序:
- 第一次执行:
- 先执行初始化条件, 在执行判断条件, 如果不成立, 就结束
- 如果成立, 就执行循环体, 然后执行控制条件.
- 第二次执行:
- 执行判断条件, 再执行循环体, 在执行控制条件
- …(重复第二次步骤)
- 最后一次:
- 执行判断条件, 不成立, 循环结束.
- 第一次执行:
- 用1,2,3,4步来陈述上述的执行流程:
- 第一次执行: 1, 2, 3, 4
- 第二次执行: 2, 3, 4
第三次执行: 2, 3, 4
… 2, 3, 4
- 第二次执行: 2, 3, 4
- 最后一次执行: 2
- 第一次执行: 1, 2, 3, 4
- 语法格式:
for循环倒序输出
- 尝试运行下面的代码
- 创建Itheima类, 创建无参无返回值test方法
- 我们来看看另外一种for循环的写法
for(int i=5 ;i>0;i--){ System.out.println(i); }
三种循环之间的区别
- 需求:
- 到目前为止, 我们学过的循环有: while, do.while, for
- 和循环相关的一些问题:
- 问题一: 什么时候使用哪种循环?
- 循环次数已知吗?
- 是: for
- 否: //一般我们会优先选择while
- 是否需要先执行一次,再判断:
- 是: do.while
- 否: while
- 是否需要先执行一次,再判断:
- 循环次数已知吗?
- 问题二: 三种循环之间的区别是什么?
- do.while循环和其他两种循环的区别:
- do.while循环是先执行一次后判断, 其他两个循环是先判断, 后决定是否执行.
- for循环和其他两个循环的区别: for循环执行完毕后, 初始化条件就不能用了, 其他两个循环执行完毕后, 初始化条件还可以继续使用.
- 这个就是我理解的这个问题.
- do.while循环和其他两种循环的区别:
- 问题一: 什么时候使用哪种循环?
泛型和包装类
- 泛型
- 概述: 泛指某种特定的数据类型, 表示形式为: <>
- 大白话: 泛型就是用来确定, 集合中将要添加什么类型的数据.
- 好处:
- 提高代码的安全性.
- 记忆:
- 泛型只能是引用数据类型.
- 泛型一般只和集合结合使用.
- 概述: 泛指某种特定的数据类型, 表示形式为: <>
- 包装类:
- 概述:
- 其实就是基本数据对应的引用数据类型.
- 各基本类型对应的包装类如下:
- 基本数据类型 对应的 引用数据类型(包装类)
- byte Byte
short Short
char Character
int Integer
long Long
float float
double Double
boolean Boolean
- byte Byte
- 基本数据类型 对应的 引用数据类型(包装类)
- 自动拆装箱(JDK1.5的新特性)
- 自动装箱: 就是把基本类型的数据转成对应的引用数据类型.
- Integer i = 10;
- 自动拆箱: 就是把引用类型的数据转成对应的基本数据类型.
- Integer i = 10;
- int a = i;
- 自动装箱: 就是把基本类型的数据转成对应的引用数据类型.
- 概述:
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(数组对象); //把数组转成其对应的字符串形式(快速打印数组的内容)
抽象类
- 概述:
- 有抽象方法的类一定是抽象类(或者接口), 抽象类中不一定有抽象方法.
- 特点:
- 1.有抽象方法的类一定是抽象类(或者接口), 抽象用关键字 abstract 修饰.
- 2.抽象类能创建对象吗?
- 不能.
- 既然抽象类不能实例化, 那么怎么实例化呢?
- 可以通过创建其子类对象, 完成实例化.
- 多态: Animal an = new Cat();
- 3.抽象类有构造方法吗?
- 有.
- 既然不能创建对象, 那么要构造方法有什么用?
- 用于子类对象访问父类数据前,对父类数据进行初始化.
- 4.抽象类的子类:
- 要么也是抽象类: 这样可以不用重写抽象方法.
- 要么是普通类: 必须重写父类中的所有抽象方法.
- 要么也是抽象类: 这样可以不用重写抽象方法.
接口
-
概述:
- 比抽象类更加抽象.
- 接口不是类, 因为接口中没有构造方法.
-
特点:
-
- 接口用 interface 关键字表示.
-
- 类实现接口用 implements 关键字表示.
-
- 接口中没有构造方法的.
-
- 接口的子类:
- 要么也是抽象类: 这样可以不用重写抽象方法.
- 要么是普通类: 必须重写父接口中的所有抽象方法.
-
-
接口的成员特点:
- JDK1.7及其以前:
- 接口中的成员有且只能有: 抽象方法或者是常量.
- 抽象方法的默认修饰符: public abstract
- 常量的默认修饰符: public static final
- JDK1.8之后:
- 接口中可以定义有方法体的方法了,
- 如果是静态可以直接写, 如果是非静态方法, 必须加default.
- JDK1.7及其以前:
类与接口之间的关系
- 类与接口之间的关系:
- 类与类: 继承关系, 只能单继承, 不能多继承, 但是可以多层继承.
- 类与接口: 实现关系, 可以单实现, 可以多实现, 还可以在继承一个类的同时实现多个接口.
- 接口与接口: 继承关系, 可以单继承,也可以多继承.
- 面试题:
- 抽象类和接口的区别是什么:
- 1.成员特点不同
- 抽象类中的成员比普通类多一种抽象方法(而且抽象方法也可以不写)
- 接口中有且只能有抽象方法(JDK1.8以后可以有带方法体的方法)或者常量.
- 2.关系特点不同
- 参考上个知识点
- 3.设计理念不同
- 抽象类: 定义的是整个继承体系的 共性内容.
- 接口: 定义的是整个继承体系的 扩展内容.
- 1.成员特点不同
- 抽象类和接口的区别是什么:
- 记忆:
- 以后我们学习一个新的体系, 都将采用: 学顶层, 用底层 的方式.
- 因为顶层记录的是整个体系的共性内容, 而底层才是具体的实现.
多态
- 概述:
- 同一事物在不同时刻表现出来的不同形态(状态).
- 前提条件:
- 1.必须要有继承(或者实现)关系.
- 2.要有父类(父接口)引用指向子类对象.
- 3.要有方法重写.
多态的访问特点
- 多态的访问特点:
- 成员变量:
- 编译看左边, 运行看左边.
- 成员方法:
- 静态: 编译看左边, 运行看左边.
- 非静态: 编译看左边, 运行看右边.
- 总结: (记忆)
- 只有非静态方法是编译看左边,运行看右边, 其他都是编译和运行都看左边.
- 原因是因为: 只有非静态方法有 方法重写.
- 成员变量:
多态的好处和弊端
- 多态的好处
- 1.提高代码的扩展性.
- 2.提高代码的可维护性.
- 多态在实际开发中最常用的应用场景:
- 父类型可以作为方法的形参的参数类型, 这样可以接受其任意的子类对象.
- 代码示例:
public static void test(Person p) { p.eat(); }
- 多态的弊端:
- 父类(父接口)引用 不能直接使用子类的特有成员(成员变量和成员方法).
- 怎么解决这个问题呢?
- 可以通过向下转型实现.
- 向上转型和向下转型: 这个概念是针对于引用类型的
- Person person = new Student(); 向上转型
- Student s = (Student)person; 向下转型
- Person person = new Student(); 向上转型
- 隐式类型转换和强制类型转换: 这个概念是针对于基本类型的
- double d = 10; 隐式类型转换
- int a = (int)d; 强制类型转换
- double d = 10; 隐式类型转换
3319
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
