【入门】java基础--2

面向对象  

对象: 一切客观存在的事物

1)属性: 有什么

2)方法: 能做什么

对象间的关系:

1.继承关系              is a    宝马汽车  汽车

2.关联关系(聚合关系)    has a   汽车  发动机  

3.依赖关系                   use a   司机  汽车

面向对象:

先找出解决问题所需要的对象, 再通过对象间的关系,完成需求

计算机中的对象: 数据 一段连续的存储空间  代表现实中的对象

1) 各司其职   简单的对象组成复杂的系统

2) 可重用性   

3) 弱耦合性 

4) 可扩展性  

类:

1. 对象的模板    对象共性的抽象

2. 客观对象在人脑中的反映  人对对象的认识

属性: 成员变量 (实例变量)

1.有默认值 

2.作用范围:本类内部

3.可以和局部变量重名,局部变量优先

方法: 

方法声明: 修饰符 返回值类型 方法名 (参数表) 抛出的异常   

          代表对象能做什么

方法实现: {}

          代表对象怎么做

重载(Overload)  方法名相同 参数表不同 (参数个数 参数类型 参数类型排列不同)

              形参名不同不属于重载, 返回值类型不同不属于重载

编译时多态:由编译器根据实参,决定调用哪个重载的方法

向上就近匹配原则

方法的重载作用:将一个类同类方法,由于参数表的不同造成的差异, 对用户屏蔽

构造方法:

1.没有返回值类型

2.方法名必须和类名相同

3.不允许手工调用 只能在对象构造过程中自动调用一次

构造对象语法: new 类名(构造参数)

对象构造过程

1.分配空间        属性被赋予默认值

2.初始化属性     属性被赋予初始值

3.调用构造方法    属性被赋予构造参数

对象类型变量 引用 : 存储对象的首地址

基本类型变量  : 存数值  

形参引用 和 实参引用 指向同一个对象

this

1) 引用:当前对象  区分局部变量和成员变量

2) 用在构造方法中 调用本类其他构造方法    必须放在构造方法的第一行

======================================================================================================

面向对象的三大特性

封装 (各司其职 可重用性)

    对象的边界 

    访问修饰符:  public   公开

                   private  私有 本类内部访问

    属性私有,为每个属性提供set/get 访问方法    

继承 (可扩展性)

    子类 is a 父类    一般 - 特殊  LSP(里氏代换原则)   

    单继承:一个子类只能有一个直接父类  类之间会形成简单的树状结构

    共性放在父类  个性放在子类

  

     父类的哪些属性或方法能继承给子类? <------> 子类能访问父类的哪些属性或方法?

     private     私有       本类内部          不能继承

     (default)   默认       本类+同包         同包子类可以继承 

     protected   受保护的   本类+同包+子类    可以继承

     public      公开                         可以继承

     方法覆盖 (重写 Override)

     子类用特殊的方法实现, 替换父类继承给它的方法实现

     访问修饰符相同或更宽, 返回值类型,方法名,参数表要相同,抛出的异常相同或更少 (子类不能抛出父类未抛出的异常)

     构造方法不能被继承,不能被覆盖

     对象构造过程:

     1.分配空间 

     2.构造父类对象

     3.初始化本类属性

     4.调用本类构造方法

     super

     1.引用, 指向父类对象  访问父类的属性,或者调用父类被覆盖的方法

     2.用在构造方法的第一行,指定调用父类的构造方法  默认为super()

多态  (弱耦合性)   

      子类对象可以赋值给父类引用

     1 只能对引用调用其引用类型中声明的方法

     2 运行时, 根据对象实际类型, 调用子类覆盖之后的方法

     3 对象类型不变

     instanceof  是不是       引用 instanceof 类名   (布尔表达式)

                              引用中的对象 是不是 类名

     多态作用: 把不同子类对象统一看作父类对象, 屏蔽不同子类的差异

     多态常见场景: 

     1. 多态用在方法参数上   m(A a): m方法可以用A的任何子类对象作为实参

     2. 多态用在方法返回值上 A m() : m方法可能返回A的任何子类对象

===============================================================================================================

修饰符 

private     属性 方法 构造方法 

(default)   属性 方法 构造方法  类 

protected   属性 方法 构造方法 

public      属性 方法 构造方法  类

abstract 抽象的

1. 类     只能声明引用, 不能创建对象

          抽象类:模板的半成品 用来被子类继承 

2. 方法   只有声明, 没有实现

如果一个类中有抽象方法, 这个类就必须是抽象类

子类继承抽象类,如果子类不希望也成为抽象类,就必须实现父类中所有的抽象方法

 私有方法,构造方法,静态方法,final方法  不能abstract 

static 静态

1. 属性   全类共有   可以用类名访问

2. 方法   类名调用

          静态方法只能访问类的静态成员 不能出现this

          静态方法只能被子类的静态方法覆盖,而且没有多态 (对引用调用静态方法,等同于对引用类型调用静态方法)

3. 初始代码块    

     静态初始代码块在类加载的时候执行一次

  类加载:当JVM第一次使用一个类时,需要把这个类所对应的字节码文件的内容读入JVM,并保存起来   

     过程: 1.如果需要,先加载父类

               2.装载

                       3.链接 (所有的静态属性分配空间,赋予默认值)

                       4.初始化 (静态属性被赋予初始值  执行静态初始代码块)

     时机: 1.第一次创建该类的对象

                      2.第一次直接访问静态成员

                       3.第一次加载该类的子类

             如果只是声明该类的引用, 不会发生类加载!!!

final

1.变量  包括局部变量  常量 一旦赋值,不能改变

        final属性,系统不再提供默认值

2.方法  不能被覆盖

3.类    不能被继承

===============================================================================================================

接口   特殊的抽象类

1.所有的方法都是公开抽象方法   public abstract

2.所有的属性都是公开静态常量   public static final

3.没有构造方法

一个类实现接口, 如果这个类不希望成为抽象类,就必须实现接口中所有的方法

接口之间可以多继承

一个类在继承父类的同时,还可以实现多个接口

接口的作用:

1.多继承

  用接口实现多继承, 不会破坏类之间树状关系的简单性

  区分主要父类和次要父类 

2.所有方法都是抽象的  -----> 标准

  解耦合   接口回调 

==============================================================================================================

内部类

成员内部类    

    不破坏封装的情况下,访问外部类的私有成员 .  用"外部类类名.this" 访问外部类当前对象

    创建成员内部类对象,要先创建外部类对象, 再通过"外部类对象.new 内部类类名()"创建内部类对象

静态内部类

    只能访问外部类的静态成员

局部内部类

    方法内部定义, 有效范围从定义开始到所在代码块结束

    不仅可以访问外部类的私有成员,还可以访问外部类的局部常量 (final)

匿名内部类   

    局部内部类的另类写法

    1) 继承某个类或是实现某个接口

    2) 只会创建该类的一个对象

堆空间 : 对象

栈空间 : 局部变量

代码空间 : 静态变量

===============================================================================================================

Object 所有Java类的父类

1. Object o   o = 任何对象

2. Object中定义的public或protected的方法, 是所有Java类都具有的方法

   1)getClass():获得对象的实际类型

   2)finalize():在对象被垃圾回收时,自动调用

     什么对象是垃圾对象? 零引用算法     

     垃圾对象何时被回收? 当内存耗尽时,一次性执行垃圾回收

   3)toString() 

     public String toString() 返回对象的字符串形式

   4)equals()

     public boolean equals(Object o)   判断this和o对象 内容是否相同

包装类   8种基本类型的对象形式

   int <-----> Integer

   char <----> Character

   double <--> Double

   自动封箱   由编译器自动完成基本类型和包装类之间的转换   since5.0

   利用包装类 区分0值和null值

=======================================================================================================
面向对象  
对象: 一切客观存在的事物
1)属性: 有什么
2)方法: 能做什么


对象间的关系:
1.继承关系              is a    宝马汽车  汽车
2.关联关系(聚合关系)    has a   汽车  发动机  
3.依赖关系              use a   司机  汽车


面向对象:
先找出解决问题所需要的对象, 再通过对象间的关系,完成需求


计算机中的对象: 数据 一段连续的存储空间  代表现实中的对象


1) 各司其职   简单的对象组成复杂的系统
2) 可重用性   
3) 弱耦合性   
4) 可扩展性   


类:
1. 对象的模板    对象共性的抽象
2. 客观对象在人脑中的反映  人对对象的认识


属性: 成员变量 (实例变量)
1.有默认值 
2.作用范围:本类内部
3.可以和局部变量重名,局部变量优先


方法: 
方法声明: 修饰符 返回值类型 方法名 (参数表) 抛出的异常   
          代表对象能做什么
方法实现: {}
          代表对象怎么做


重载(Overload)  方法名相同 参数表不同 (参数个数 参数类型 参数类型排列不同)
                形参名不同不属于重载, 返回值类型不同不属于重载
编译时多态:由编译器根据实参,决定调用哪个重载的方法
向上就近匹配原则


方法的重载作用:将一个类同类方法,由于参数表的不同造成的差异, 对用户屏蔽


构造方法:
1.没有返回值类型
2.方法名必须和类名相同
3.不允许手工调用 只能在对象构造过程中自动调用一次


构造对象语法: new 类名(构造参数)
对象构造过程
1.分配空间       属性被赋予默认值
2.初始化属性     属性被赋予初始值
3.调用构造方法   属性被赋予构造参数


对象类型变量 引用 : 存储对象的首地址
基本类型变量  : 存数值  


形参引用 和 实参引用 指向同一个对象


this
1) 引用:当前对象  区分局部变量和成员变量
2) 用在构造方法中 调用本类其他构造方法    必须放在构造方法的第一行


======================================================================================================
面向对象的三大特性
封装 (各司其职 可重用性)
    对象的边界  
    访问修饰符:  public   公开
                 private  私有 本类内部访问
    
    属性私有,为每个属性提供set/get 访问方法    


继承 (可扩展性)
    子类 is a 父类    一般 - 特殊  LSP(里氏代换原则)   
    单继承:一个子类只能有一个直接父类  类之间会形成简单的树状结构
    共性放在父类  个性放在子类 




     父类的哪些属性或方法能继承给子类? <------> 子类能访问父类的哪些属性或方法?
     private     私有       本类内部          不能继承
     (default)   默认       本类+同包         同包子类可以继承 
     protected   受保护的   本类+同包+子类    可以继承
     public      公开                         可以继承


     方法覆盖 (重写 Override)
     子类用特殊的方法实现, 替换父类继承给它的方法实现
     访问修饰符相同或更宽, 返回值类型,方法名,参数表要相同,抛出的异常相同或更少 (子类不能抛出父类未抛出的异常)


     构造方法不能被继承,不能被覆盖


     对象构造过程:
     1.分配空间 
     2.构造父类对象
     3.初始化本类属性
     4.调用本类构造方法
 
     super
     1.引用, 指向父类对象  访问父类的属性,或者调用父类被覆盖的方法
     2.用在构造方法的第一行,指定调用父类的构造方法  默认为super()
多态  (弱耦合性)   
      子类对象可以赋值给父类引用
     1 只能对引用调用其引用类型中声明的方法
     2 运行时, 根据对象实际类型, 调用子类覆盖之后的方法
     3 对象类型不变


     instanceof  是不是       引用 instanceof 类名   (布尔表达式)
                              引用中的对象 是不是 类名


     多态作用: 把不同子类对象统一看作父类对象, 屏蔽不同子类的差异
     多态常见场景: 
     1. 多态用在方法参数上   m(A a): m方法可以用A的任何子类对象作为实参
     2. 多态用在方法返回值上 A m() : m方法可能返回A的任何子类对象


===============================================================================================================
修饰符 
private     属性 方法 构造方法 
(default)   属性 方法 构造方法  类 
protected   属性 方法 构造方法 
public      属性 方法 构造方法  类


abstract 抽象的
1. 类     只能声明引用, 不能创建对象
          抽象类:模板的半成品 用来被子类继承 
2. 方法   只有声明, 没有实现


如果一个类中有抽象方法, 这个类就必须是抽象类
子类继承抽象类,如果子类不希望也成为抽象类,就必须实现父类中所有的抽象方法
 
私有方法,构造方法,静态方法,final方法  不能abstract 


static 静态
1. 属性   全类共有   可以用类名访问


2. 方法   类名调用
          静态方法只能访问类的静态成员 不能出现this
          静态方法只能被子类的静态方法覆盖,而且没有多态 (对引用调用静态方法,等同于对引用类型调用静态方法)


3. 初始代码块    
     静态初始代码块在类加载的时候执行一次
   类加载:当JVM第一次使用一个类时,需要把这个类所对应的字节码文件的内容读入JVM,并保存起来    
     过程: 1.如果需要,先加载父类
           2.装载
           3.链接 (所有的静态属性分配空间,赋予默认值)
           4.初始化 (静态属性被赋予初始值  执行静态初始代码块)


     时机: 1.第一次创建该类的对象
           2.第一次直接访问静态成员
           3.第一次加载该类的子类
           如果只是声明该类的引用, 不会发生类加载!!!


final
1.变量  包括局部变量  常量 一旦赋值,不能改变
        final属性,系统不再提供默认值
         
2.方法  不能被覆盖
3.类    不能被继承


===============================================================================================================
接口   特殊的抽象类
1.所有的方法都是公开抽象方法   public abstract
2.所有的属性都是公开静态常量   public static final
3.没有构造方法


一个类实现接口, 如果这个类不希望成为抽象类,就必须实现接口中所有的方法


接口之间可以多继承
一个类在继承父类的同时,还可以实现多个接口


接口的作用:
1.多继承
  用接口实现多继承, 不会破坏类之间树状关系的简单性
  区分主要父类和次要父类 
2.所有方法都是抽象的  -----> 标准
  解耦合   接口回调 
  
==============================================================================================================
内部类
成员内部类    
    不破坏封装的情况下,访问外部类的私有成员 .  用"外部类类名.this" 访问外部类当前对象
    创建成员内部类对象,要先创建外部类对象, 再通过"外部类对象.new 内部类类名()"创建内部类对象


静态内部类
    只能访问外部类的静态成员


局部内部类
    方法内部定义, 有效范围从定义开始到所在代码块结束
    不仅可以访问外部类的私有成员,还可以访问外部类的局部常量 (final)
匿名内部类   
    局部内部类的另类写法
    1) 继承某个类或是实现某个接口
    2) 只会创建该类的一个对象


堆空间 : 对象
栈空间 : 局部变量
代码空间 : 静态变量


===============================================================================================================
Object 所有Java类的父类


1. Object o   o = 任何对象
2. Object中定义的public或protected的方法, 是所有Java类都具有的方法
   1)getClass():获得对象的实际类型
   2)finalize():在对象被垃圾回收时,自动调用
     什么对象是垃圾对象? 零引用算法     
     垃圾对象何时被回收? 当内存耗尽时,一次性执行垃圾回收
   3)toString() 
     public String toString() 返回对象的字符串形式
   4)equals()
     public boolean equals(Object o)   判断this和o对象 内容是否相同


包装类   8种基本类型的对象形式
   int <-----> Integer
   char <----> Character
   double <--> Double
     
   自动封箱   由编译器自动完成基本类型和包装类之间的转换   since5.0
   
   利用包装类 区分0值和null值

============================================================================================================

String

charAt(int index):通过下标获得字符

toCharArray():返回char[]

String(char[] cs):利用字符数组构造String

toUpperCase()/toLowerCase():转大写/转小写

length():字符串长度

trim():去掉字符串前后的空格和换行

startsWith(String str):判断String是否以str开头

endsWith(String str):判断String是否以str结尾

indexOf(String str):返回子串在String中首下标

indexOf(String str,int begin):从begin位置开始找, 返回子串的首下标

lastIndexOf(String str):从后往前找 找子串首下标

replace(String str,String str2):用str2子串替换str子串

substring(int begin,int end):返回begin到end下标的子串 子串包含起始下标,不包含结束下标

split(String str):以str为分隔符,将字符串拆分为多个子串 返回String[]

String:内容不变

StringBuilder:内容可变

intern():返回String在串池中的地址

串池:减少重复的对象, 资源共用