本文章记录笔者在学习Java历程中总结的一些简单问题，以便后续复习回顾，后面的天数内会有重复的问题
DAY03
- 第一个Java代码
class Hello {
public static void main (String[] args) {
System.out.println("hello world");
}
}
- 八大基本数据类型
整型: byte short int long
浮点: float double
字符: char
布尔: boolean
- 声明整型和浮点和布尔类型的数据
int a = 20;
float f1 = 23.4f;
double d1 = 3648;
- 变量名字的命名规范
1.首字母小写
2.由数字，字母，_ , $组成的，不能以数字开头
3.见名知意
4.小驼峰 或者_组成
5.不能以Java的关键字
- 算术运算符有哪些
- * / % += -= *= /= %=
DAY04
- 八大基本数据类型
byte short int long 开发中用int
float double
char 使用单引号
boolean
- 逻辑短路原则
逻辑或短路：只要⼀个为真，或结果就为真，后⾯的不算了。
逻辑与短路：只要有⼀个为假，结果就为假。
如果&&左边的算式结果为假，那么右边的不再运⾏，直接得出结果为假。
8.if分支语法格式和执行流程
if (布尔表达式) {
语句体
}
执行流程: 如果布尔表达式为true， 就执行大括号里面的语句体。 如果布尔表达式为false，就跳过大括号里面的语句体，接着往下执行
9.if-else分支语法格式和执行流程
if (布尔表达式) {
语句体1
} else {
语句体2
}
执行流程： 如果布尔表达式为true 执行语句体1 ，如果布尔表达式为false 执行 语句体2
最重要的看布尔表达式值。 两者只能选择其一。
10.if-else if分支语法格式和执行流程
if (布尔表达式1) {
语句体1
} else if (布尔表达式2) {
语句体2
} else if (布尔表达式n) {
语句体n
} else {
语句体n+1
}
执行流程：
如果碰到if语句后面的小括号中的表达式为true的时候，就执行相对应的大括号后面的语句体
其他语句体一概不执行
应用场景： 多种情况
11.switch-case语法格式
swicth (表达式) {
case 常量1:
语句体1;
break;
case 常量2:
语句体2;
break;
case 常量3:
语句体3;
break;
...
default:
语句体n;
break;
}
执行流程： switch后面小括号中的表达式值 去和 case后面的常量进行匹配。如果他们两个一样的话
就执行当前的语句体，其他语句体不执行
12.swith关键字后面的小括号中的表达式可以是什么数据类型？
switch(表达式) {
}
byte short int char String 枚举
13.控制台输入的代码如何写 ？
- 获取int类型的数据 nextInt()
- 获取字符串类型的数据 next()
- 获取字符类型的数据 next().charAt(0)
Scanner scanner = new Scanner(System.in);
//获取控制台输入的int类型的数据
System.out.println("请输入一个整数:");
int a = sb.nextInt();
System.out.println("Line11: " + a);
//获取控制台输入的byte类型的数据
System.out.println("请输入一个整数:");
byte b = sb.nextByte();
System.out.println("Line14:" + b);
//获取控制台输入的float类型的数据
System.out.println("请输入一个小数:");
float f1 = sb.nextFloat();
System.out.println("Line18:" + f1);
//获取控制台输入的布尔类型的数据
System.out.println("请输入一个布尔类型的数据:");
boolean b1 = sb.nextBoolean();
System.out.println("Line23:" + b1);
//获取控制台输入的字符串类型的数据
System.out.println("请输入一个字符串:");
String str = sb.next();//获取控制台字符串的方法
System.out.println("呵呵哒:" +str);
//获取控制台输入的字符类型的数据
System.out.println("请输入一个字符串:");
//sb.next() 取控制台的字符串的： 例如 abcdef
//charAt(0) 取你字符串中 第一个位置的字符 a
//charAt(1)取你字符串中 第二个位置的字符 b
char ch = sb.next().charAt(0);
System.out.println("Line32:" + ch);
//字符的获取 是在字符串的基础之上 获取的
DAY05
- switch后面的小括号里面的 数据类型是那种数据类型?
byte short int char String 枚举
- if-else的语法格式
if (布尔表达式) {
语句体1
} else {
语句体2
}
- switch-case的语法格式
swicth (表达式) {
case 常量1:
语句体1;
break;
case 常量2:
语句体2;
break;
case 常量3:
语句体3;
break;
...
default:
语句体n;
break;
}
- 逻辑的短路原则
逻辑或短路：只要⼀个为真，或结果就为真，后⾯的不算了。
逻辑与短路：只要有⼀个为假，结果就为假。
如果&&左边的算式结果为假，那么右边的不再运⾏，直接得出结果为假。
- while循环的语法格式及执行流程
while (布尔表达式) {
语句体
}
执行流程: 当代码执行到while关键字的时候，先去判断布尔表达式，如果布尔表达式为false，就不会执行语句体。
如果布尔表达式为true 执行语句体，然后（重要） 再去判断布尔表达式，如果布尔表达式为true
执行语句体，然后再去判断布尔表达式，直到布尔表达式为false的时候，循环就结束了（就不再执行语句体了）。接着执行循环以外的代码
- while和do-while的循环的区别
do {
语句体
} while(布尔表达式);
Do while和while的区别就是do while不管条件是否成立，都至少执行一次。
- for循环的语法格式和执行流程
for (表达式1; 布尔表达式2; 表达式3) {
语句体
}
表达式1： 初始化的条件
表达式2: 终止条件
表达式3: 循环条件
执行流程: 首先执行表达式1，再执行表达式2，如果布尔表达式2为true，执行大括号中语句体。然后再执行表达式3，再执行表达式2，再次判断布尔表达式2，直到为false，就不执行语句体。就意味着循环结束
- 使用for循环打印99乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
...
找规律 几行 9行 第一行 1列 第二行 2列 ....
每行的列数和 每行息息相关的
public class Demo15 {
public static void main(String[] args) {
//打印九九乘法表
for (int i = 1; i < 10; i++) {
for (int j = 1; j <= i; j++) {
//1*2=2
System.out.print(j + "*" + i + "=" + i*j + "\t");
}
System.out.println();
}
}
}
DAY06
- 八大基本数据类型
byte short int long char boolean float double
- 声明变量的语法格式
数据类型 变量名字 = 值;
- 使用for循环打印等腰三角形
for (int i = 1; i <= 4; i++) {//行
for(int j = 1; j <= 4-i; j++) {//打印的空格
System.out.print(" ");
}
for (int j = 1; j <= 2*i-1; j++) {//打印*
System.out.print("*");
}
System.out.println();
}
- break和continue关键字的简单介绍
break 在循环和switch中使用 终止 打断
continue 在循环中使用 终止本次的循环，然后进入到下一次的循环
- 四种方法的语法格式分别列出来
无参无返回值的方法：
public static void 方法的名字() {
}
有参无返回值的方法
public static void 方法的名字 (数据类型 变量1, 数据类型 变量2,...) {
}
无参有返回值的
public static 数据类型 方法的名字() {
return 返回值;//返回值的数据类型和方法的声明处的数据类型保持一致的
}
有参有返回值的
public static 数据类型 方法的名字 (数据类I型 变量1, 数据类型 变量2,...) {
return 返回值;
}
DAY07
- return关键字的用法
return返回 有返回值的方法的时候才用 关键字return
return 后面必须是返回的值
下面一行不可以有代码，代表结束
循环中 不能使用return关键字
- 声明方法的四种形式
无参 无返回值的
有参 无返回值的
无参有返回值的
有参 有返回值的
- 什么是形参，什么是实参
在方法的声明处叫 形参 形式参数
在方法的调用处叫实参
- 数组的三种声明方法
1. s数据类型[] 数组的名字 = {值1, 值2, 值3,...};
int[] arr = {1,2,3,4};
2.数据类型[] 数组的名字 = new 数据类型[容量];
int[] arr = new int[3];
arr = {0,0,0};
3.数据类型[] 数组的名字 = new 数据类型[]{值1, 值2, 值3,...};
- 对第二种数组进行声明的时候如何进行赋值
int[] arr = new int[3];//arr = {0,0,0}
arr[0] = 78;//[78,0,0]
DAY09
- 声明一个类的语法格式
calss Person {
属性
String name;
方法
public void eat () {
}
}
- 通过类创建一个对象
Person person1 = new Person();
- 无参数的构造方法语法格式
public 类名 () {
}
- 有参数构造方法的语法格式
public Person (String name, int age) {
this.name = name;
this.age = age;
}
- 构造方法的作用是啥
初始化对象
- 在类中声明方法的语法格式是什么
无参无返回值的方法
public static void 方法的名字 () {
语句体
}
有参无返回值的方法
public static void 方法的名字 (数据类型 变量1, 数据类型 变量2,... ) {
语句体
}
无参有返回值的方法
public static 数据类型 方法的名字() {
return 返回的数据;
}
有参有返回值的方法
public static 数据类型 方法的名字 (数据类型 变量1, 数据类型 变量2,...) {
return 返回的数据;
}
DAY10
- 构造代码块和构造方法的区别
构造代码块：
语法格式
{
语句体
}
构造方法：
public 类 () {
}
- 局部变量和成员变量区别
| 区别 | 成员变量 | 局部变量 |
|---|---|---|
| 定位位置 | 类的大括号的后面 也叫属性 | 定义在方法体中 |
| 作用 | 描述一个类的属性或者特征的 | 在方法体中保存变量的值的 |
| 初始化的值 | 有默认的初始值String=>null int ==>0 | 没有默认的值使用的时候一定要赋值 |
| 作用域 | 作用整个类 | 只能在当前方法中使用 |
- 声明类的语法格式
class Person {
属性
构造方法
方法
}
- 一个类中属性的意义是啥
描述一类的事物的特征， 主要目的对对象进行存储值的
String name;
- 构造方法的语法格式
无参构造方法：
public 类 () {
}
有参构造方法：
public 类 (形参) {
}
- 逻辑运算符的简单介绍
& 和 &&
相同点：
这两个逻辑运算符都表示：“与”，一个为False，全为False。
区别：
&：表达式a & 表达式b 在运算时，表达式a和b都会被执行，进行True和False的判断。
&&：表达式a && 表达式b 在运算时，如果表达式a为False，则表达式b不进行运算，直接返回结果，计算效率高。
| 和 ||
相同点：
这两个逻辑运算符都表示：“或”，一个为True，全为True。
区别：
|：表达式a | 表达式b 在运算时，表达式a和b都会被执行，进行True和False的判断。
||：表达式a || 表达式b 在运算时，如果表达式a为True，则表达式b不进行运算，直接返回结果，计算效率高。
!
逻辑非：取相反结果
^
逻辑异或：相同为False，相异为True
————————————————
版权声明：本文为CSDN博主「Kevinllli」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_42516475/article/details/121722155
- 对属性进行封装 如何封装
1.对属性加上private 修饰
2.写 set和get方法
DAY11
- 多类合作：成年人类（包含）孩子属性（包含）玩具属性
class RenLei {//人类
String name;
int age;
BigDog bigDog;//bigDog这个对象带了三个数据 牛彩云 3 黑色
}
class BigDog {
String name;
int age;
String color;
}
public class Demo8 {
public static void main(String[] args) {
BigDog bd = new BigDog();
bd.name = "牛彩云";
bd.age = 3;
bd.color = "黑色";
RenLei renLei = new RenLei();
renLei.name = "二贝";
renLei.age = 38;
renLei.bigDog = bd;
System.out.println(renLei.name);
System.out.println(renLei.age);
//人的狗 狗的名字
System.out.println(renLei.bigDog);//内存地址
System.out.println(renLei.bigDog.name);// 牛彩云
System.out.println(renLei.bigDog.age);//3
System.out.println(renLei.bigDog.color);//黑色
}
}
- 继承的语法格式
class A {
}
class B extends A {
}
B可以继承A非私有化的属性和方法
- this关键字的使用
this代表是当前的对象
1.this可以调用属性和方法
2.this可以调用构造方法
DAY12
- 成员变量和局部变量的区别
内存地址: 局部变量在栈区 成员变量 在堆区
作用域: 局部变量一般在方法中 成员变量 整个类中
赋值方式: 局部变量在使用一定要赋值，没有默认值的 成员变量有默认值
- 继承的语法格式
关键字 extends
class A {
}
class B extends A {
}
- 子类继承父类一些要求关于属性和方法
子类只能继承父类中的public或者默认的属性或者方法
- 重写的目的
重写的目的： 和继承有关 重写的是方法 子类是可以继承父类的非私有化的方法的
但是有的时候父类的方法需求满足不了子类的需求了，这个时候在子类中需要重写父类的方法
- 重写和重载的区别
重写【override】
1.必须是继承关系
2.在子类中去重写父类的方法
3.在子类的重写的方法 要求必须方法名字 一样 参数一样 返回值一样
重载【overload】
1.必须在同一个类中
2.方法的名字必须一样
3.方法的参数必须不一样
4.方法的返回值可以一样可以不一样
5.无参构造方法和有参构造方法 是方法的重载
- this和super的区别
this:
代表当前的对象
1.this可以调用属性和方法
2.this可以调用构造方法
super:
代表是父类的对象
1.super可以调用属性和方法 【不太重要】
2.super可以调用父类的构造方法
- 抽象类详解 共9条
1.如果一个类中有抽象方法，那么这个类一定是抽象类
2.抽象方法是一个没有方法体的方法，是一个不完整的方法
3.抽象类中能有普通方法吗？ 可以
4.抽象类能被实例化吗？ 不能
5.抽象类不能被实例化，然后可以使用普通类去继承抽象类
6.在子类中 必须去重写父类的所有的抽象方法，让抽象方法变得有意义
7.在抽象类中，非抽象的方法能不能在子类被重写的，可以的
8.一个抽象类可以继承另外一个抽象类
9.一个抽象类也可以继承一个非抽象的类
DAY13
- 抽象类的声明语法格式
abstract class Person {
属性
普通方法
抽象方法
}
- 关于声明和使用抽象类得注意事项（共9条）
1.如果一个类中有抽象方法，那么这个类一定是抽象类
2.抽象方法是一个没有方法体的方法，是一个不完整的方法
3.抽象类中能有普通方法吗？ 可以
4.抽象类能被实例化吗？ 不能
5.抽象类不能被实例化，然后可以使用普通类去继承抽象类
6.在子类中 必须去重写父类的所有的抽象方法，让抽象方法变得有意义
7.在抽象类中，非抽象的方法能不能在子类被重写的，可以的
8.一个抽象类可以继承另外一个抽象类
9.一个抽象类也可以继承一个非抽象的类
- final关键字
final：
字面意思: 最终的 最后的意思 修饰符
用法：
1.final可以修饰成员变量
final修饰的成员变量必须初始化（赋值），一旦被赋值之后，就无法被修改
2.final可以修饰局部变量
final修饰的局部变量可以暂时不用赋值， 使用的时候必须赋值，一旦赋值以后就不能改了
3.final可以修饰成员方法
final修饰的方法不能被子类重写
4.final可以修饰类
final修饰的类 不能被继承
5.final可以修饰对象的引用
这个引用一旦被赋值 就无法被修改
- 接口得声明语法格式
interface A {
属性 常量 由public static final 修饰的
方法 一般都是抽象方法 void eat();
}
- 关于声明和使用接口的注意事项（共9条）
1.使用关键字 interface来声明Java中的接口
2.接口下面是可以有属性的， 只不过属性必须赋值，因为默认带了 public static final 表示的是常量
3.接口下面 的方法都是抽象方法，尽管没有带abstract 默认也是public的
4.接口下面是一般都是抽象方法 有特殊的情况呢jdk1.8之后，增加了可以使用default修饰的方法 是可以带有方法体的
5.接口下面没有构造方法，就意味无法实例化
6.用一个普通类去实现（implements）接口
7.实现接口的时候一定要重写所有的抽象的方法，默认的方法可以重写也可以不写
8.一个类可以实现（implements）多个接口 写法 implements D, C,F
9.一个接口可以去继承（extends）另外一个接口
DAY14
- 多态的向上转型和向下转型
向上转型： 父类的引用指向子类的对象
父类 父类的引用=new 子类（）; //会自动转
向下转型：子类 子类的引用=（子类） 父类的引用 先向上转型，再向下转型
- instanceof关键字的用法
A instanceof B
A：对象名字
B：类
- 抽象类声明方式
abstract class Person{
public abstract void eat();
}
- 接口的声明方式
inteface A{
}
- 继承的语法格式
class B extends A{
}
- 重写与重载
1.定义不同---重载是定义相同的方法名，参数不同；重写是子类重写父类的方法。
2.范围不同---重载是在一个类中，重写是子类与父类之间的。
3.多态不同---重载是编译时的多态性，重写是运行时的多态性。
4.返回不同---重载对返回类型没有要求，而重写要求返回类型，有兼容的返回类型。
5.参数不同---重载的参数个数、参数类型、参数顺序可以不同，而重写父子方法参数必须相同。
6.修饰不同---重载对访问修饰没有特殊要求，重写访问修饰符的限制一定要大于被重写方法的访问修饰符。
- final关键字的用法
1.final修饰成员变量 必须赋值 一旦赋值 无法修改
2.final 修饰局部变量 可以先不赋值 使用的时候赋值 一旦赋值 无法修改
3.final 修饰方法 不能被重写
4.final 修饰类 不能被继承
5.final 修饰对象的引用 这个对象的引用不能再赋值了 fianl Person person = new Person();
DAY15
- static 关键字用法
1.static 修饰成员变量 使用 类名.属性名字
2.static 修饰成员方法 使用 类名.方法名字 不能使用非静态的属性和方法的
3.static 修饰代码块 只要类加载了 这个静态代码块会执行的
- final关键字用法
1.final修饰成员变量 必须赋值 一旦赋值 无法修改
2.final 修饰局部变量 可以先不赋值 使用的时候赋值 一旦赋值 无法修改
3.final 修饰方法 不能被重写
4.final 修饰类 不能被继承
5.final 修饰对象的引用 这个对象的引用不能再赋值了 fianl Person person = new Person();
- 接口的使用
interface A {
}
接口都是抽象的方法 或者 是default修饰的方法
普通类 实现 implements 接口 必须重写所有的抽象的方法
- 抽象类的使用
abstract class B {
}
普通类 继承抽象类 必须重写抽象的方法
- 多态的理解
方法的多态 : 重写 和重载
对象的多态 ： 向上转型 父类的引用指向子类的对象
方法的参数是父类的引用 实参 是子类的真实的对象
- 继承的理解
class B extends A {
}
1464
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
