JavaSE
位运算符
A&B 都有1则为1 其余全为0
A|B 都为0则为0 其余全为1
A^B 相同则为0 不同则为1
~B 全部取反
<< 左移 相当于*2 >>右移 相当于 /2
字符串连接符
int a = 10;int b = 20;
System.out.println(" "+a+b)//输出结果为1020,如果空字符串在前,则默认把后面当作string处理,进行拼接
System.out.println(a+b+" ")//输出结果为30,如果空字符串在后,则前面正常计算
三元运算符
x?y:z//如果x==true,则结果为y,否则结果为z
Scanner
java.util.Scanner//输入
通过Scanner类的next()与nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r6eqx6L6-1647350262364)(C:\Users\周俊杰\AppData\Roaming\Typora\typora-user-images\image-20211031182235633.png)]
next()//以空格作为分隔符和结束符
nextLine()//以回车判断是否结束
For的增强
int [] numbers = {1,2,3,4,5};
for(int x : numbers){
System.out.println(x);
}
针对于数组与集合
构造器
- 和类名相同
- 没有返回值
作用
- new 本质在调用构造方法
- 初始化对象的值
注意点
- 定义有参构造之后,如果想使用午餐构造,显示的定义一个无参构造
- Ider快捷方式:Alt + Insert
封装
“高内聚低耦合” 高内聚就是内部数据操作细节自己完成,不允许外部干涉;低耦合:仅暴露少量的方法给外部使用
意义:
- 提高程序的安全性,保护数据
- 隐藏代码的实现细节
- 统一接口
- 系统可维护性增加了
多用get ()和set ()
super
注意点:
- super调用父类的构造方法,必须在构造方法的第一个
- super必须只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
对比this
代表的对象不同:
this:本身调用者这个对象
super:代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法
this():本类的构造
super():父类的构造!
方法的重写
前期:需要有继承关系,子类重写父类的方法!
- 方法名必须相同
- 参数列表必须相同
- 修饰符:范围可以扩大,但不能缩小 public>protected>Default>private
- 抛出的异常:范围,可以缩小,但不能扩大
必须为非静态的,子类的方法和父类必须一致,方法体不同!
为什么要重写:
1. 父类的功能,子类不一定需要,或者不一定满足
2. 快捷方法 Alt + Insert 选中override
多态
注意事项
- 多态是方法的多态,属性没有多态
- 父类和子类有联系
- 存在的条件:继承关系,方法需要重写,父类引用指向子类对象。
instanceof
(类型转换),引用类型,判断一个对象是什么类型
System.out.println(person instanceof Student);
System.out.println(X instanceof Y);
//X与Y有父子关系,则编译通过,相反编译错误
//有关系返回Ture,相反False
类型之间的转换:高转低(强制转换),低转高(直接转换)
条件:
- 父类引用指向子类的对象
- 把子类转换为父类,向上转型(可能会丢失自己本来的一些方法)
- 把父类转换为子类,向下转型(强制转换)
static的详细总结
- 静态属性、静态方法可以被类中的方法直接使用,不需要new对象
代码块
代码块
public class Person{
{
//代码块(匿名代码块)
}
static{
//静态代码块
}
public Person(){
//构造方法
}
}
执行顺序:
- 静态代码块
- 匿名代码块 (可以用来赋初值)
- 构造方法
注意:static静态只执行一次
包的导入
import static java.lang.Math//静态导入包
final
被final修饰的类,不能在被继承
抽象类 abstract
public abstract class Action{
public void demo1()//正常运行
public abstract void demo2()//正常运行
public abstract void demo3(){
//报错
}
}
- abstract,抽象方法,只有方法名字,没有方法的实现!
- 抽象类的所有方法,继承了它的子类,都必须实现它的方法,除非继承它的类也是抽象类
抽象类的特点:
- 抽象类不能new,只能靠子类去实现它
- 抽象类中可以写普通方法
- 抽象方法必须在抽象类中
接口
声明接口的关键词为***interface***,接口都需要有实现类
public interface UserService{
//接口中所有定义其实都是抽象的 public abstra
//所有定义的属性都为常量
/*public static final*/ int AGE = 99;
/*public abstract */ void add(String name);
/*public abstract */ void delete(String name);
/*public abstract */ void update(String name);
/*public abstract */ void query(String name);
}
public class UserServiceImpl implements UserService{
public void add(String name){
}
public void delete(String name){
}
public void update(Sting name){
}
public void query(String name){
}
}
抽象类:extends
接口:implements
//实现了接口的类,就需要重写接口中的方法
//使用接口可以变相的实现多继承
作用:
- 约束
- 定义一些方法,让不同的人实现
- 方法都是public abstract
- 变量都是public static final
- 结果不能被实例化,接口中没有构造方法
- implements可以实现多个接口
- 必须要重写接口中的方法
内部类
成员内部类
package demo;
public class Outer{
private int id = 10;
public void out(){
System.out.println("这是外部内的方法");
}
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
public void getID(){
System.out,println(id);//成功打印出“10”
//可以获得外部类的私有属性
}
}
}
package demo;
pubilc class APPlication{
public static void main(String[] args){
Outer outer = new Outer();
//通过外部类来是实例化内部类
outer.new Inner()
inner.in()//可以打印出“这是内部类的方法”
}
}
package demo;
public class Outer{
//局部内部类
public void method(){
class Inner{
}
}
}
异常 Exception
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wuekgLV0-1647350262365)(C:\Users\周俊杰\AppData\Roaming\Typora\typora-user-images\image-20211109130908001.png)]
抛出异常
publicpublic class Demo {
public static void main(String[] args) {
int a = 1;
int b = 0;
try{
System.out.println(a/b);
}catch(ArithmeticException e){
System.out.println("程序出现异常,变量b不能为0");
}finally {
System.out.println("finally");
}//finally可以不要,一般在输出输入流中,需要关闭文件中使用
}
}
//快捷键,选中后 Ctrl + Alt + T
//假设要捕获多个异常,需要层层递进
import com.Text;
public class Demo {
public static void main(String[] args) {
try {
new Demo().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
//假设这方法中,处理不了这个异常,就在方法上抛出异常throws
public void test(int a,int b)throws ArithmeticException{
if(b == 0){
throw new ArithmeticException();//主动的抛出异常,一般在方法中使用
}
}
}
自定义异常
在程序中使用自定义异常类,大体可以分为以下几个步骤:
- 创建自定义异常类
- 在方法中通过throw关键字抛出异常对象
- 如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明初通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作
- 在出现异常方法的调用者中捕获并处理异常
注意:用户自定义异常类,需要继承Exception类
package zjj;
public class Demo extends Exception{
//传递一个数字,如果大于10,就丢出去
private int detail;
public MyException(int a) {
this.detail = a;
}
//toString:异常的打印信息
@Override
public String toString() {
return "MyException{" + "detail=" + detail + '}';
}
}
package zjj;
public class TEST {
//可能会存在的方法
static void test(int a) throws MyException{
System.out.println("传递的参数为:"+a);
if (a > 10){
throw new MyException(a);//抛出
}
System.out.println("OK");
}
public static void main(String[] args) {
try {
test(1);
} catch (MyException e) {
System.out.println("MyException=>"+e);
}
}
}
实际应用
- 处理运行时异常时,采用逻辑去合理规避同时辅助try-catch处理
- 在多重catch块后面,可以一个catch(Exception)来处理可能会被遗漏的异常
- 对于不确定的代码,也可以加上try-catch,处理潜在的异常 //Alt + Enter
- 尽量去处理异常,切忌只是简单地调用printStackTrace()去打印输出
- 具体如何处理异常,要根据不同的业务需求和异常类型去决定
- 尽量添加finally语句块去释放占用的资源