一 类和对象
类class
定义语法: class 类名{
属性
构造方法(参数){
为属性赋值
}
void 方法(参数){
}
%构造方法
在创建对象时被调用用来赋予属性值
1.与类名同
2.不加返回类型
%当局部变量参与成员变量一样时
%可以通过增加构造方法的idea功能可以直接生成构造方法
语法: this 变量
this用来指局部变量(类中的)
对象object
创造对象: new 类名(参数);
引用对象: 类名(类型) 对象名=new 类名(参数);
调用对象: 对象名.属性;
”对象名.方法名(参数)
%默认值
面向对象的使用方法
1.把相关的数据分出来
2.写方法执行行为
(静态变量)static和(不能修改值)final
static所定义的变量是类的,对象共用
比如: 同一个类所定义出的不同对象调用的static变量是共用的
带final的不能重新赋值或改值
四种变量
1.参数变量
范围:方法调用开始到方法调用结束
2.局部变量
范围:从定义开始到包围他的}结束
3.对象变量(成员变量)
范围:从对象创造开始到对象不能用
4.静态变量
范围:从类开始到类卸载
继承
语法: class 子类名 extands 父类名
继承功能:
1.可以用父类的方法与变量,避免了代码的重复
2.只要通过子类的构造给父类提供数据即可
继承的特点:
1.单继承 2.每个未继承类都继承了object
3.子类和父类,祖满足(是什么)
当父类中有带参构造时子类也得建立构造方法
子类构造方法的语法: 子类名(父类构造方法的参数){
super(父类的参数)
}
%Alt+entr可以通过idea功能快速建立子类构造方法
普通方法与对象方法
普通方法的变量只能来于自己的参数变量
对象方法变量来自于参数变量和对象变量
类型
1.基本类型primitive
byte short long int float double char
boolean
2.引用类型reference
String byte[] int[] 对象
包装类型
Byte Short Long Intger Float Double character Boolean
语法:Byte 名字=new Byte();
引用类型 名字=new 引用类型()
可以调用Byte的方法,属性
类型的转换
1.基本类型
2.包装类型和基本类型
3.引用类型之间的转换
a.顺着箭头方向(向上转换)
Animal a=new cat() a本质还是cat的对象
要求:对象之间满足 是一个
作用:1. static void test(Animal cat){
}
调用这个方法时test(new cat())也可以test(new dog())
2.创建数组时 Animal[] b=new Animal[]{
new cat() new dog()}
b.逆着箭头方法(向下转换)
cat a=new Animal[]错误的语法
Animal b=new cat[]
cat a=(cat)Animal
要求:1.对象之间满足 是一个
2.引用必须原来是和子类相同类型就安全
作用:可以将向上的变为向下的
%classcastexception 转化
getclass
获得他的类型:System.out.println(a.getclass())
instanceof
判读是不是属于类
System.out.println(a instanceof Animal)
4.不属于以上三种的转换
借助方法
String转为int
String a="1"
String b="2"
System.out.println(a+b)
System.out.println(Inget.parseint (a)+Inget.parseint (b))
多态
多态是一个方法可以由不同的对象输出不同的结果
语法
class 父类{
void way(){}
}
class 子1 extands 父类{
void way(){子1的方法}
}
class 子2 extands 父类{
void way (){子2的方法}
}
调用: 父类 a=new 子1()
父类 b=new 子2()
a.way() 输出子1的方法
b.way() 输出子2的方法
封装
将数据封装防止被修改
修饰符
1.public 谁都可以用
2.protected(默认) 同包
3.private 同类
JavaBean
规范
1.字段私有 private int ci
get方法来调用
public int getCi(){
return this.ci}
set方法来修改
public int setCi(){
this.ci=ci}
is方法调用布尔类
static boolean a=ture
public boolean isa(){return this.a}
在main方法中创造对象后调用方法进而调用变量
2.最好用无参
3.最好用接口
JavaBean中的字段只要用了get和set就说这个字段是他的属性
接口
可以解决单继承
inteface A{
public dafult void a(){
}
}
inteface B{
public dafult void b(){
}
}
class c implement A,B
多态
条件:1.用父类(接口)代替子类
用数组来获取子类
2.必须重写方法
方法
语法 inteface E{e(){}}
class A implement E{e(){}}
class B implement E{e(){}}
E[] o=new E[]{new A(),new B()}
for(i=0;i<o.length;i++){
o[i].e();
}
注意:子类的方法的权限应该大于等于父类的
抽象方法
1. public abstract void 方法名();
2.作用可以减少方法体的代码
3.必须重写方法
封装
接口类 n=new 子类()
只可以调用接口类中有的方法变量
Spring 控制反转 依赖注入
@Contronller 控制器
@Service 业务逻辑
对象的创造权转到spring上叫控制反转
框架帮你找一些对象按一定规则输出叫依赖注入
@Automired
类型 名字;
只可以找@Sercice的对象
%当用接口类型就包括所有的实现类达到多态
%顺序由名字来
创造请求JavaBean
1.有参时直接赋值
2.无参时通过get set方法赋值
包结构
服务器只可以识别本包内 的@controller,@service
Arraylist
输出:system.out.ptintln(Arrays.toString(数组名))
Arraylist list=new Arraylist(个数)个数默认值为10
增加元素: list.add(元素);
输出:System.out.println(list.toString())
debug
通过断点来看运行时的内部工作
1.选断点
2.调试
3.点击要看的右键选择查看
4.选object
5.跳步
6.计算机手动输入代码
遍历
普通数组和Arraylist都可以用
for(类型(Arraylist一般用object) 变量名字 : 遍历的名){
system.out.println(变量名字)
}
Arraylist里面可以存任意引用类型 普通类型会转换为引用类型 int-integer-object 最终都会变成object,在输出时也是object
可以将他转换为原来的类型向下转换
泛型
Arraylist<引用类型> 名字= new Arraylist<引用类型>()
在输出时,会转回<>里面的类型
加了<>的只可以存入和泛型有关系的类型
List接口和实现
List<引用类型> 名字=List.of(数据)
定义后不可以改变数据
List<Integer> list2=List.of(1,2,3)
System.out.println(list2.getclass())
定义后可以改变数据 Arraylist
一般List和ArrayList这样用结合用
List<Integer> list=new Arraylist()
list.addAll(list2)
list.addAll(List.of(数据))
Map
Map<索引类型,内容类型> map=Map.of(索引,内容,);不可变Map
map.get(key); 输出内容
Map<索引类型,内容类型> map=new HashMap();可变Map
map.put("索引,内容") 输入与修改
map.get(索引)获得
map.remove(索引)删除
map.entrySet();获得所有数组
for(Map.Entry<索引类型,内容类型> 名字 :map.entrySet()){
System.out.println("key"+名字.getKey()+"value")
}
异常 try catch
try{
有异常的代码
}catch(类型 e){
System.out.println(e)
}
当有异常时向上到main在到虚拟机就结束了
catch中类型最好选父类类型
spring处理异常
自动的
编译异常vs运行异常
编译异常
1.自己用try{}catch(异常类型 e){}来处理
2.在本方法参数中加throws 异常类型
finally
try{}catch(){}finally{}
无论有没有异常都会执行
在关闭资源时可以省略方法
class resource implement closeable{
@Ocerride
public void close(){
}
}
try(resource r=new resource()){}catch(){}