Java基础重点注意事项

Java基础重点注意事项

1.变量:
格式:数据类型 变量名 = 值;
注意事项:
1.变量没有初始化,不能直接使用.
2.在一个作用域中,不要出现同名变量.
3.不同的作用域,尽量不要相互使用.
4.先定义以及赋值,再使用.
2.标识符:
规范:
1.类:大驼峰.
2.方法和变量:小驼峰.
注意事项:
1.不可以用数字开头.
2.不可以和关键字重名.
3.强制类型转换:
格式:数据类型取值范围小的 变量名 = (数据类型取值范围小的)数据类型取值范围大的.
注意事项:
1.强转尽量不要随便使用,会出现数据丢失,溢出.
2.byte short char参与运算时会先提升为int型.
拓展:
1.byte,short,char直接赋值,只要不超出范围,javac会自动强转(隐式)
2.byte,short,char 的等号右边的值,如果是两个整数常量相加,只要不超出范围,javac会自动强转(隐式)
3.但是,如果byte,short,char的等号右边的值参数运算的时候出现了变量,那么需要我们自己强转,java就不会自动强转了
4.算数运算符:
+ - * / %
+的拼接:任何类型遇到字符串,都会变成字符串,直接拼接.
自增 自减:
1.单独使用符号在前在后无所谓.
2.混合使用:
1.符号在前:先算再用.
2.符号在后:先用再算.
5.赋值运算符
= += -= *= /= %=
展开:num += 1 --> num = num + 1
注意事项:
byte short char 在参与赋值运算时,不用我们强转,自动提升.
6.比较运算符
== > < >= <= !=
注意事项:
比较运算符返回的是boolean类型.
7.逻辑运算符
&& || !
8.三元运算
格式:boolean表达式?表达式1:表达式2
执行流程:
1.先走boolean表达式
2.如果返回true走?后面的表达式1
3.如果返回false走:后面的表达式2
9.判断语句
格式:
1.if(boolean表达式){执行语句}
2.if(boolean表达式){执行流程}else{执行语句}
3.if(boolean表达式){执行语句}else if(boolean表达式){执行语句}else{执行语句}
10.选择语句
格式:switch(表达式){case 常量值1:执行语句;break; case 常量值2:执行语句;break;default:执行语句;break; }
注意事项:
没有break出现case穿透性,直到遇到break或者代码结束为止.
11.for循环
格式:for(初始化变量;比较;步进表达式){循环体}
注意事项:
1.初始化变量,执行了一次
2.for循环中的前两部分,决定了范围.
3.步进表达式(变量变化),决定了变化的次数.
12.while循环
格式:初始化变量;while(比较){循环体;步进表达式;}
for循环与while循环的区别:
1.for循环定义变量在里面,所以变量会随着for循环结束而消失,节省内存.循环里的变量不能继续使用.
2.while循环定义变量在外面,这个变量不会随着while结束而消失,可以继续使用这个初始化变量.
13.跳出语句
1.break :结束循环
2.continue :结束当前循环,进行下一次循环
3.return :结束当前整个类
14.死循环
条件永远成立
例如:
1.while(true)
2.for(;?
15.嵌套for循环
for中有for
执行流程:
先走外层循环,如果条件成立,进入内层循环,内层循环一直循环到结束,外层循环进入到第二次循环.
16.方法
概述:功能的集合,有功能的代码块
格式:修饰符 返回值类型 方法名(参数){方法体 return值}
调用方式:
1.单独调用:方法名(参数); 没有返回值
2.打印调用:System.out.println(方法名(参数)) 有返回值
3.赋值调用:数据类型 变量名 = 方法名(参数)
sout(变量名); 有返回值
注意事项:
1.方法不调用不执行
2.方法不能嵌套
3.方法之间是平级的
4.方法的执行顺序和调用顺序有关
5.方法的返回值类型要和方法的返回结果类型一致
6.方法中void和return值不能共存,但是void能和return共存(void代表没有返回值)
7.如果有返回值我们在调用的时候要将返回会来的值输出出来.
如果没有返回值,我们一般直接在自己的方法中将结果输出出来.
8.调用方法的时候,要看下面有没有完全对应的方法
(包括方法名,参数个数,参数数据类型)
9.一个方法中不能出现两个return值
(因为这个return值将结果返回并结束方法)
参数和返回值的运用时机:
参数:
1.什么时候用参数:方法中不能确定要操作什么具体数据,需要调用的时候确定,需要别人给我数据.
2.什么时候不用参数:方法中能自己解决数据,不需要别人给我传递具体值.
返回值:
1.什么时候用返回值:当调用处需要被调用者的结果,再次进行逻辑处理,就需要返回值.
2.什么时候不用返回值:调用处不需要被调用者的结果.
形参与实参:
形式参数:当定义方法的时候,定义的参数没有给具体的值
实际参数:在调用方法的时候,给了参数具体的值
17.方法的重载
概述:方法名相同,参数列表不同.
怎么判断参数列表不同:
1.什么叫参数列表不同:(有关)
参数个数不同
参数类型不同
参数类型的顺序不同

     2.无关:
       跟返回值类型无关
       跟参数的变量名无关

     3.总结:想判断方法是不是重载,只看方法名和参数列表

18.数组
特点:长度定长,长度不可变
格式:
1.动态:数据类型[] 数组名 = new 数据类型[长度]
2.静态:数据类型[] 数组名 = new 数据类型[]{元素1…}
3.静态简化:数据类型[] 数组名 = {元素1…}
区别:
1.静态初始化:在定义的时候确定元素,定义的时候没有直接长度,但可以根据储存的元素个数确定长度.
2.动态初始化:在定义的时候没有确定具体元素,直接给了长度.
索引:
概述:每一个元素的位置.
特点:从0开始,最大length-1.
获取元素:
格式:数组名[索引]
添加元素:
格式:数组名[索引]=值
获取数组长度:
数组名.length
遍历:
格式: for(int i=0;i<数组名.length;i++){sout(数组名[i])}
常见问题:
数组常见的两个问题:
1.ArrayIndexOutOfBoundsException:数组越界异常–>我们操作的索引,超出了数组的最大索引,或者说是超出了数组的长度
2.NullPointerException:空指针异常–>引用数据类型为null时,在操作这个数据,就会出现空指针异常
19.面向对象:
概念:
面向对象:在java开发过程中,我们不注重其具体过程,自己的事情自己不做,找对象帮我做–>懒.
面向过程:C 每一步都需要自己亲历亲为.
特点:
1.符合我们的思考习惯
2.将复杂的事情简单化
3.从一个执行者变成指挥者
20.类
类:一类事物的描述,是抽象的
public class ClassName {
//成员变量
//成员方法
}
属性:成员变量–>定义在类中,方法外的
数据类型 变量名 -->默认值
行为:这一类事物的功能(动作)–>成员方法
修饰符 返回值类型 方法名(参数){
方法体
}
21.对象
对象的创建和使用:
1.导包–>找到我们想使用的类中内容–>同一个包中不用导包
import 包名.包名.包名.类名
2.创建对象–>我们想使用哪个类中的成员,就根据这个类创建这个类的对象
类名 对象名 =new 类名()
3.使用该对象中的成员(变量,方法)–>想使用这个对象中的哪个成员,就点哪个成员名
对象名.成员变量=值
对象名.成员方法(实际参数)
成员变量和局部变量的区别:
1. - 在类中的位置不同 重点
- 成员变量：类中，方法外
- 局部变量：方法中或者方法声明上(形式参数)
2. - 作用范围不一样 重点
- 成员变量：类中
- 局部变量：方法中
3. - 初始化值的不同 重点
- 成员变量：有默认值
- 局部变量：没有默认值。必须先定义，赋值，最后使用
4. - 在内存中的位置不同 了解
- 成员变量：堆内存
- 局部变量：栈内存
5. - 生命周期不同 了解
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
22.封装
概述:保护数据
表现形式
1.将代码放在方法中
2.private
使用方法: private 数据类型 变量名
get/set
1.set :给成员变量赋值
2.get :获取成员变量的值
this :
概述:代表本类成员
使用方法:this.成员变量名
作用:可以区分重名的局部变量和成员变量
谁调用this所在的地方,谁就是this
23.构造
无参:
作用:创建对象,并执行无参构造方法
注意:没有写,java自己给一个
有参:
作用:创建对象,执行有参构造方法,给属性赋值
注意:写了有参,java就不提供无参构造方法
24.快速定义标准类
快捷键:alt+inse
复习方法:用快捷键快速定义一个类,创建对象,操作类中的成员.
25.API
字典,会查就行.
类信息,构造,方法.
26.Scanner
概述: 键盘录入
数据类型: 引用数据类型
使用:
1.导包
2.创建对象: Scanner sc=new Scanner(System.in)
3.调用方法: nextxxx()
27.Random
概述: 随机数
数据类型: 引用数据类型
使用:
1.导包
2.创建对象: Random rd=new Random()
3.调用方法:
1. nextint() 在正负21亿之间随机
2. nextint(int n) 在0-(n-1)范围内随机
例如1-100之间随机: nextint(100)+1
28.匿名对象
概述: 没有名字的对象
使用: new 类名().成员
注意事项:
如果我们自己定义的方法只使用一次,我们就可以用匿名对象
29.ArrayList集合:
概述: 容器
作用: 存数据
数据类型: 引用数据类型
1.特点:
1.长度可变
2.有很多功能强大的方法
3.只能储存引用数据类型
基本类型所对应的引用数据类型:
包装类(引用数据类型)
byte Byte
short Short
char Character
int Integer
long Long
float Float
double Double
boolean Boolean
从引用数据类型(包装)转成基本数据类型–>拆箱
从基本数据类型转成包装类–>装箱
2.使用:
方法:
1.add(元素) 添加元素.
2.remove(int index) 根据索引删除元素
3.get(int index) 获取制定索引位置上的元素
4.size() 获取集合长度
拓展方法:
1.void add(int index,E element) 往制定索引位置上添加元素
2.boolean contains(Object o) 判断我们指定的位置的元素是不是在集合中
3.boolean remove(Object o) 删除指定元素
4.E set(int index,E element) 将指定索引位置的元素替换成我们指定的元素
5.void clear() 清空集合
3.遍历:
for(int i=0;i<list.size();i++){
sout(list.get(i));
}
快捷键: 集合名.fori
30.String
概述: 表示字符串
特点:
1.每个""都是String的对象
2.字符串定义出来不能改变
3.可以作为数据共享
定义:
1.构造:
1.public String()
2.public String(char[])
3.public String(byte)
4.public String(String str)
2.简化:
String 变量名=字符串值
面试题:
String s=new String(“abc”) 有几个对象?
答案:2个 new 一个 abc一个
方法:
1.判断方法:
1.public boolean equals(Object anObject)
将此字符串与指定对象进行比较.–>比较的是字符串的内容
2. public boolean equalsIgnoreCase (String anotherString)
比较的是字符串的内容,忽略大小写.
2.获取方法:
1. public int length () ：返回此字符串的长度。
2. public String concat (String str) ：将指定的字符串连接到该字符串的末尾。,字符串拼接,会产生一个新的字符串

		3. public char charAt (int index) ：返回指定索引处的 char值。--根据索引来获取对应的字符

		4. public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。-->获取指定字符串在该串中第一次出现的索引位置

		5. public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。

		6. public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex
	3.转换功能:
		1. public char[] toCharArray () ：将此字符串转换为新的字符数组。
		2. public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
		3. public String replace (CharSequence target, CharSequence replacement) ：
                               将与target匹配的字符串使用replacement字符串替换

                               将前面的替换成后面的
	4.分割功能:
		1. public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。
	5.扩展方法:
		1.	去空格
			String trim()
			去掉字符串两端空格
			但是如果字符串中间有空格,方法无效


		2.	转大小写:
			String toLowerCase()  将字母转成小写
			String toUpperCase()  将字母转成大写

31.static:
概述:静态关键字
特点:被static修饰的成员属于类,不属于对象
用法:
1.修饰成员变量:
static 数据类型 变量名
2.访问:
1.创建对象, 变量名=值 不推荐
2.类名.变量名=值 推荐
注意事项:
1.静态方法,不能直接调用非静态的
原因:静态的属于类,非静态的属于对象,静态的成员优先于对象存在的

					如果先要访问,请先new对象,再调用非静态的成员

		2.非静态的能直接访问静态的

					访问:
					如果在同一个类中,我们可以直接调用,或者可以类名直接调用方法
					如果不在用一个类中,我们必须类名去点

		3.静态的能直接访问静态的
					访问:
					如果在同一个类中,直接调用,也可以类名调用
					如果不在同一类中,类名直接调用
	静态代码块:
		格式: static{}
		特点: 优先于构造执行,并只执行一次

32.Arrays:
概述: 操作数组的工具类
特点:方法都是Static的
使用:Arrays.方法名(参数)
方法:
1.toString(数组) 按照一定的格式输出数组的字符串表示形式
2.sort(数组) 针对数字从小到大 针对字母字典形式 大写在前
33.Math:
概述: 关于数学的工具类
特点: 方法都是static的
使用: Math.方法名(参数)
方法:
1.public static double abs(double a): 返回double的绝对值.
2.public static double ceil(double a): 返回大于定于参数的最小的整数.
3.public static double floor(double a): 返回小于等于参数最大的整数.
4.public static long round(double a): 四舍五入.
34.继承:
概述: 将一类事物的共性抽出来形成父类.
格式: 子类 extends 父类
特点: 子类可以直接拥有父类的非私有的成员.
访问成员变量:
不重名: 如果创建的是父类对象:那么只能调用自己父类中的成员
如果创建的是子类对象,那么既能调用从父类继承过来的
也能调用子类特有的.
重名: 直接使用:看等号左边的是谁,就先调用谁中的成员变量,如果没有,就找父类
通过方法去使用成员变量:还得看等号左边是谁,就先访问谁中的成员变量,如果没有,找父类
总结:子债父偿
访问成员方法:
不重名: 如果创建的是父类对象:只能调用父类的成员方法
如果创建的是子类对象:既能调用子类的方法,又可以调用从父类继承过来的方法
重名: 看new 的是谁就先调用谁中的方法,没有的话找父类
方法的重写:
1.格式: 子类中建一个和父类一样的方法
2.使用场景: 方法的增强
35.关键字:
1.this: 概述:本类的成员
访问本类的成员变量: this.变量名
访问本类的成员方法: this.成员方法名
访问本类的构造方法: this(参数)
2.super: 概述:代表的是父类成员
访问父类成员变量: 在子类方法中 super.变量名
访问父类构造方法: 在子类构造方法中 super(参数)
访问父类成员方法: 在子类方法中 super.成员方法名(参数)
36.抽象:
概述: 说不清,道不明.
抽象方法: 修饰符 abstract class 类名
抽象类: abstract class 类名.
注意: 1.将一类事物的共性的方法抽取出来形成一个父类,
而该方法不能确定具体实现,可以视为抽象方法.
2.抽象方法所在的类是抽象类.
3.抽象类中可以没有抽象方法.
4.抽象类中啥都可以有.
扩展:
1.继承中,Static的不能被继承
2.构造方法不能被继承.
37.final:
概述:最终的.
类:不能被继承.
成员变量:
1.必须初始化
2.初始化之后不能二次赋值
成员方法:
1.不能被重写.
局部变量:
1.基本数据类型: 不能被二次赋值
2.引用数据类型: 地址值不能变,内容能变.
38.权限修饰符:

                          public-->    protected-->  default(不写权限修饰符)-->   private

同类 yes yes yes yes

同包不同类 yes yes yes no

不同包的子类 yes yes no no

不同包的非子类 yes no no no

39.接口:
概述: 一类事物的标准.
定义格式: interface
抽象方法:
定义格式:public abstract 返回值类型 方法名(参数);
访问:
1.创建实现类,implements 接口
2.重写抽象方法.
3.创建实现类对象,调用重写的方法
默认方法:
定义格式:public default 返回值类型 方法名(参数){
方法体
}
访问: 创建实现类对象,调用默认方法
注意: 可以被重写,但是被重写之后,再调用,肯定是重写之后的.
静态方法:
定义格式:public static 返回值类型 方法名(参数){
方法体;
}
访问: 接口名.方法名(参数)
成员变量:
定义格式: public static final 数据类型 变量名=值
访问: 接口名.变量名
注意:
1.可以不写 static final,但是java默认给一个
2.必须手动赋值
3.不能二次赋值
4.一般变量名大写(习惯)
接口多实现以及(继承多实现)的使用特点以及注意事项:
1.接口可以多实现–>一个实现类,可以实现多个接口
格式:
实现类 implements 接口A,接口B{
必须重写调所有接口中的抽象方法
}

			2.一个实现类可以继承一个父类的同时实现一个或者多个接口
				格式:
					子类(实现类) extends 父类 implements 接口A,接口B{
						必须重写掉父类以及接口中的所有的抽象方法
						}


			3.注意事项
				1.一个类继承一个父类的同时实现一个或者多个接口,要重写所有的抽象方法
				2.如果两个接口中有重名的抽象方法,那么我们就可以重写一个
				3.如果两个接口中有重名的默认方法,那么我们必须重写一个
				4.如果接口中有和父类的成员方法一样的默认方法,那么我们先执行父类的
	接口可以多继承:		
			如果两个父接口中有重名的默认方法,子接口中必须重写一次
	接口中没有静态代码块,和构造方法
	
	接口和抽象类的区别:
			接口:
				1.成员单一,一般都是功能.
				2.可以多继承,多实现.
				3.继承的同时,实现.
			抽象类:
				1.啥都可以有.
				2.只能单继承,但是支持多层继承

40.多态:
概述: 一个事物有不同的形态.
特点:
1.必须有子父类继承关系,或者实现关系.
2.必须有重写方法,如果没有重写,多态没有意义.
3.父类引用指向子类对象.
访问特点:
成员变量:看等号左边的是谁,先访问谁.
成员方法:
1.先调用重写的,如果没有找父类.
2.但是不能调用子类特有的.
格式:
父类 对象名 = new 子类()
转型:
1.向上: 默认的.
2.向下:
强转:
父类 对象名 = new 子类()
子类 对象名 = (子类)父类
弊端:
类型转换异常,等号左右两边的类型不一致.
关键字:
instanceof :
格式:对象 instanceof 对象
判断此关键字前的类型是不是属于关键字后面的对象
好处:提高代码的拓展性:
父类类型或者接口作为方法参数,可以接受任何属于他们的
子类或者显示类,就调用哪个子类或现实类中的重写方法.
41.内部类:
格式: class A{
classB{

					}
				}
	成员: 
		注意:
			1.内部类能直接使用外部类的成员
			2.外部类不能直接使用内部类的成员.
		使用: 外部类名.内部类名 对象名 = new 外部类型().new 内部类型();
	匿名:
		作用:四合一.
		场景:如果方法只使用一次
		格式:
			匿名内部类:
  原始调用eat()
    1.创建子类继承父类(或者实现类实现接口)
    2.重写方法
    3.创建子类对象
    4.调用重写方法

  匿名内部类:四合一


  格式:
		new 父类或者接口(){
		重写方法

		}.方法名;


		或者
		父类 对象名 = new 父类或者接口(){
			重写方法

			};

		对象名.重写的方法名

		注意:new 父类或者接口()代表的是子类对象