java基础的一些概念.够自己有时间查看

面向对象:oop


一 面向对象与面对过程的区别




类的成员
一>类的属性
1.  成员变量 与 局部变量
  相同点；1.遵循变量的声明格式。 数据类型 变量名=初始化值
          2.都有作用域
   不同点:1.声明的位置不同:成员变量：声明在类里,方法外
                           局部变量:声明在方法内,方法的形参部分,代码块内
 2.成员变量的修饰符有四个:public private protected 缺省
    局部变量没有修饰符,与所在的防范修饰符一样
 3.初始化值:一定有初始化值
   成员变量:如果在声明的时候,不显示赋值,那么不同的数据类型会有不同的默认初始化值
byte 字节 short 短的  int   long长的  >0
float double >0.0
char >空格
boolean>false
引用类型变量> null
局部变量:一定要显示的赋值(局部变量没有默认的初始化值)
4.二者在内存中存放的位置不同：成员变量存在于堆空间中.局部变量:栈空间中

二>.类的方法


3.重载 overload
要求:1.同一个类中 2.方法名相同  3.方法的参数列表不同(参数个数,类型不同)
注:方法的重载与方法的返回值类型没有关系


三个double的最大值
(d1,d2)>3?(d1,d2):d3;








三>构造器 <Constructor>
作用：1.创建对象   2.给创建的对象赋值
   1.设计类时.若不显示声明类的构造器的话.程序会默认提供一个空参的构造器
   2.有显示的定义构造器.默认的构造器不在提供
   3.声明格式 修饰符 类名(形参) {}
   4.类的多个构造器之间构成重载
//构造器
public AA(){}
   二.类对象的属性赋值的先后顺序.1.属性的默认初始化 2.属性的显示赋值 3.构造器赋值
                                 









内存划分结构: 
栈 局部变量 对象的引用名  数组的引用名
堆 new出来的东西《含成员变量》
方法区 含字符的常量
静态域 声明static的变量

匿名类对象：创建类的对象是匿名的.  new A.a();
          1.一次使用调用类对象的情况下.使用
          2.特点只能调用一次


5.0 开始有


可变个数的形参
格式:对于方法的形参: 数据类型 ... 形参名
2.可变个数的形参方法.与同名的方法构成重载
3.可变个数的形参在调用时.个数从0到n
4.使用多个形参与 String[]是一样的
5.方法中有可变个数的形参要放到最后<方法中最多有一个可变方法的形参>
例:
 public void add(String ... str){
for(int i=0;i<str.length;i++){}
 }
 
 
 方法的参数传递
   1.形参 方法声明时.方法()里的参数
     实参 调用方法时.实际传入的参数的值
   2.规则：java中的参数传递机制:值传递机制
           值传递机制 1.形参是基本数据类型：将实参的值传递给形参的基本数据类型
                      2.形参是引用数据类型： 将实参的引用类型变量的值(对应的堆空间的对象实体的首地址值)
 传递给形参的引用类型
 
 面向对象特征  <抽象> 封装  继承 多态
 
 一: 封装<隐藏>
  封装就是将属性私有化，提供公有的方法访问私有属性。
   权限:
    public  缺省<本包> protected<本包加子类> private 私有的<本类>
在继承的情况下 public 缺省 protected  可直接用.private不行


抛出手动异常
 throw new RuntimeException("xxx");
 


this  关键字


1.可以用来修饰属性 方法 构造器
2.this理解为当前对象或当前创建的对象  this.name  this.show()
3.this(形参) 显示调用当前的本类的构造器 注:在构造器中调用其他的构造器必须this()放到第一行
4.一个类中有n个构造器.最多有n-1个构造器总是用this(形参) 




 
2.继承:<extends>   class a extends b 
  a:子类 b:父类
   1.子类继承父类.得到父类的属性 方法
      父类有私有的方法属性是.之类同样可以获取的到.由于封装性的设计.使得不能直接调用.通过类点属性方法
   2.java 继承只能单继承
   3.之父类是相对的概念
   
   重写:前提   子类继承父类.子类对父类的方法重写覆盖 
        规则:1.子类的方法 的 返回值 方法名 参数列表一样
    2.子类方法的修饰符不能小于父类的修饰符
3.若父类方法抛异常.子类方法抛的异常不能大于父类
4.子父类的方法必须为static 或非static
         注:父类方法private 子类就算同名 放回值类型 参数列表 不是重写
      
 重载与重写的区别:
 重载:两同一不同 同类同方法名  不同点参数列表.  方法的重载与方法的返回值类型没有关系
 重写:前提 在继承基础之上获取父类的结构属性方法.  
       方法的返回值 方法名 参数列表相同- 权限的修饰符不小于父类可以相同  -子类方法的异常不大于父类的异常
同为static或同为不static

 super
    1.访问或调用父类的属性成员方法.子类构造方法中调用父类的构造器
注:1.当子父类出现相同的成员可以用super区别
       2.this本类的引用  super代表父类内存空间标识
2.super修饰构造器.在子类使用super(形参列表)调用父类显示构造器
        1>在构造器内部的首行.
   2>在构造器内部. this(形参列表) 和 super(形参列表) 只能出现一个
   3>在构建器中不显示调用super 或者this super   默认调用父类空参的构造器
        4>object 根父类
5.有可能出现父类没有空参构造器.  建议设计一个类时.尽量提供一个空参的构造器
 
package：声明源文件的所在的包
import:引入类  Scanner:键盘输入类  lang下不用导入路径如：System String  math
        import static 表示导入指定类的static的属性或方法



  多态:事物的多种表现形态
   1.方法的重载和重写 2.子类对象的多态性<  父类 s=new 子类();
注:执行的是子类的方法-或者子类重写父类的方法.子类特有的.父类不能调用>

使用前提:
1.类的继承 2.子类对父类的重写

instanceof ：
  格式.对象a instanceof 类a 判断对象是否是类a的一个实例.是的话返回true。否的话返回false
若:a是A类的实例.那么a也一定是A类的父类实例
4.多态不适用于属性
      
  
  
   
  
  
  
  
  
  
java Object
  1.equals
        1>   ==
          1.基本数据.两端数据类型可以不同
          2.引用类型.比较引用类型变量的地址值是否相等 false
          
        2>equals 
 java.lang.Object类.所有类的根基类
 1.处理引用类型变量.
 2.在object类中发现equals比较的是引用变量的地址是否相等
   例:String 包装类 Date 重写了equals方法.比较的是两个对象的实体内容
 




java String 


  2.toString       便于输出
String str1="sdf";adf在字符串常量池里  
        输出默认调用toSring方法






static   静态的.修饰  属性 方法 代码块(初始化块) 内部类
1.修饰属性(类变量)存放在  静态域中
  1>通过类创建的对象.公用这个属性. 当某对象对此属性进行了修改.其他对象的这个属性也都进行修改
           2>只要加载了这个类.就进行加载.(独一份) 实例对象new 对象时加载 --类变量的加载早与对象
  3>类对象(静态变量). 可以通过 类.类变量
  


2.修饰方法(类方法)
          1.随类加载而加载.内存中独一份.  可类.类方法
 2.只能调用  静态变量 静态方法.反之非静态方法可以调用静态变量.和方法
 
 注:静态 属性 方法 代码块 内部类 生命周期早于非静态结构.回收晚于非静态结构
        3.构造器里不分静态非静态
静态方法里不能有this super  关键字








java 设计模式  23种设类计模式
  1.单例-一个类只能创建一个对象
     1>私有化构造器
     2>在类部.构建一个类的static 实例
     3>s私有化对象.通过公共方法(static)调用
  










 属性赋值操作:1.默认初始化.2.显示初始化或代码块《按照顺序执行》 3.构造器。通过方法对对象的相应属性进行修改
初始化块     {}   只能使用static修饰


1.静态代码块


  1.早于非静态早于构造器  随着类的加载而加载.自加载一次
  3.多个静态按照顺序执行 只能对静态属性 方法操作






2.非静态代码块
  1.对类的属性(静态非静态都可以)进行初始化操作
  2.里面可以有输出语句
  3.一个类中可以有多个代码块.多个按照循序执行
  4.没创建对象 加载{}   非静态代码块
  5.先执行代码块.再是构造器
  


final 最终
    标记的类不能继承. String StringBuffer System 
    方法不能重写  object里的getClass
    属性为常量   常量一般为大写 <没有默认初始化.可以 显示赋值,代码块,构造器>初始化赋值后不能在赋值
    变量用static final 修饰成为全局常量


  finally 异常  finalize()垃圾回收




    


抽象类  abstract Class 哦不斯却可得
不能修饰属性<不能覆盖>,构造器<不能重写>,private final static


抽象类
  1.不能实例化   还是有构造器<凡是类都有构造器>
            有抽象方法所在的类.一定是抽象类
   抽象类可以没有抽象方法


抽象方法
格式:没有方法体 没有{}    public abstract void ss();
 子类继承抽象类.必须重写所有方法.不要要定义为抽象类





System.currentTimeMillis();看代码执行的时间
math.sqrt(i);


   2.模板方法设计模式《确定的内容放到父类进行抽象,不确定的让子类实现》


运用抽象.
    


接口 interface 只包含常量 抽象方法不包含变量,一般的方法,构造器
   常量:都用public static final 
   抽象方法；public abstract
  实现:implements
   注.重写所有的抽象方法.才能实例化.若没有任是抽象类
   类单继承  接口多实现 


   定义规范.解除耦合关系
     
   模式
     工厂方法的设计模式  factoryMethod




     代理模式
       








  
内部类
 一个类的定义位于另一个类的内部.
 前者成为内部类.后者成为外部类
  
  类的里面在定义类
  分类：
    成员内部类--与方法成员变量 方法 并列用
    区部内部类--方法里
    


    1.成员内部类
      1>外部类的一个成员 1.有4个修饰符 2.static final 
可以调用外部类的属性方法


      2>具有类的特点 1.abstract 2.可以有属性.方法.构造器




问题:
1.创建成员内部类对象() 
  static的内部类.可以通过外部类创建对象
  外部类.内部类 d=new 外部类.内部类();
  非static 通过外部类对象调用内部类的构造器


2.如何区分调用外部类,内部类的变量
  在内部类中通过对象区分.  




    4.局部内部类《方法里》
一个方法返回一个类.或者一个借口.在这个方法里创建对象




java相关的主要包:
1.java.lang 包含一些java语言的核心类.String Math Integer,System,Thread
2.java.net 包含执行与网络相关的操作类和接口
3.java.io 包含能提供多种输入/输出功能的类
4.java.util 包含一些使用工具类.如定义系统特性.接口的集合框架类.使用日期日历相关的额函数
5.java.text 包含java格式化的相关的类
6.java.sql 包含java进行JDBC数据库编程的相关类/接口
7.java.awt 包含构成抽象窗口工具集.(bastract,window,toolkits)的多个类.这些类被用来构建和管理应用程序的图形用户界面(GUI)
8.java.applet 包含applet运行所需的一些类


          
 javaBean
  满足条件：
  1.类是公共的 2.有一个无参的公共的构造器
  3.有属性 且有get set方法
  
 uml 类图
  1.  :  前是属性名 后是属性类型
  2.  方法的下有下滑线表示为构造方法
  3. + 表示public - 表示private #表示protected
  4. 方法的写法 --  方法的类型(+,-)  方法名(参数名:参数类型)：返回值类型
  






  


  异常处理
        error 错误.程序不进行处理


exception 程序中可以处理的




   常见异常: