Java面向对象学习笔记

 

一  类和对象

类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(){}