java基础--面向对象

java语言核心

1.   面向对象

     1》  封装(成员/方法的定义、构造方法、访问控制、内部类、static、final)

         a.成员/方法的定义,内存结构

              jvm内存可以分为：方法区、堆、栈

                   方法区：类的信息(类的定义、方法代码、静态成员)持久的（自定义类在第一次被使用时装载的方法区  注意：JDK的核心类是在jvm启动的时候自动装入的）－－唯一的（只会装一次）                    

                   堆：通过new关键字创建的对象

                       持有（被引用指向、对象在集合中）、回收（当对象不再被持有时回收）

                   栈：在方法中声明的局部变量

                       方法调用完之后立即清空

                       建议垃圾回收system.gc();

         b.   构造方法

              初始化成员变量

              子类的构造方法必须调用父类的构造方法，为了保证子类中从父类继承的成员被妥善的初始化，一般情况下java类都要提供一个无参的构造方法

         c.访问空值

              类：(非内部类)public defualt

              成员：public protected default private

                   public：1是类对外提供的功能    2     尽量要保证其稳定性   3 要对参数进行合法性验证，保证其健壮性(//IllegalArgumentException非法参数异常)   4    必须妥善的处理异常

                   private：同一类才可用 一个类中，多个方法中的公共部分

                   protected：子类可用  多个类中的冗余部分，在父类中封装

                  

                   成员变量和属性的区别!!!

                       设置emp对象的xxx属性为“goodman“    等价于调用emp的setXxx("goodman");

             

 

         d.内部类

              公有类   public

              包内类   default

              内部类   定义在一个类内部（多线程）

              匿名类   定义在一个方法中

 

         e.static

              定义在类中的一个方法，该方法不对该类的对象进行操作，其操作仅仅和输入相关（参数）。

              定义在该类中完全是出于逻辑上的考虑

              static成员

              staticfinal  常量   在编译的时候会被替换成常量值，定义该常量的类甚至都不会被加载。

 

         f.final

              类前很少写final，动态代理

              方法前写final，防止方法被无意中重写

 

     2》  类和类之间的关系(关联、依赖、继承)

         关联：

              publicclass A{

                   privateB b;

              }

              publicclass B{}

         依赖：

              publicclass A{

                   publicvoid f(B b){}

                   publicB g(){}

              }

              publicclass B{}

             

              依赖优于关联（如果仅仅是一个方法用到，不需要关联）

              关联优于继承＊＊＊（如果仅仅是重用，不需要继承）

 

     3》  多态(抽象类、接口)

              接口：只有抽象方法的抽象类

 

 

 

     4》  常见的设计模式

    

 

2.   javaSE核心

     1》  String、StringBuilder、(Commons)

         String类

              不要写new String();

              1.intlength() 

              2.booleanequals 不要出现：String name="" name.equals “lsdf”;因为name可能为空

              3.booleanequalsignoreCase(不区分大小写比较)

              4.intindexOf(string); int indexOf(String str,int fromIndex)

              5.Stringsubstring(int start,int end)

              6.string[]split(String regx)//参数是正则表达式

              7.Stringtrim()

 

         StringBuilder

              1.StringBuilderappend(...)

              2.delete(intstart, int end)

              3.insert(...,intfromIndex)

        

     2》  Date、Calendar、SimpleDateFormat

         java.util.Date

              newDate();

              longgetTime();

              setTime(long);

 

         java.util.Calendar抽象类

              CalendargetInstance()//获取系统所在地即系统的Calendar种类（种类：中国、日本、泰国）

              set(Calendar.Year,2013)

              get(Calendar.DAY_OF_WEEK)

        

         SimpleDateFormat

              SimpleDateFormatsdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//模式匹配  yyyy-MM-dd HH:mm:ss模式匹配字符

              Stringformat(Date)

              Dateparse(String)//可能出异常

 

     3》  集合框架、ArrayList、HashMap

         List：线性表   排序，按下标索引

         Map：查找表  查找

         常见的实现类：

              ArrayList,LinkedList

              HashMap,TreeMap

         常用的方法：

              List<Ee>

              追加：boolean add(E e);

              插入：boolean add(int index,E e);

              删除：remove(E e); (和equals)

                   remove(intindex);

              获取：E get(int index);

              更改：E set(int index,E e);

                   set(i,list.set(j,list.get(i)));

              是否包含：contains(Object obj);(和equals)

              清空： clear();

              大小：size();

              addAll(),removeAll();

        

        

         Map<K,V>

              put(k,Vv);

              Vget(K k);

              booleancontainsKey(K k);

             

              遍历

              Map<String,Object>map = new HashMap<String,Object>();

              Set<String>keys = map.keySet();

              for(Stringkey:keys){

                   System.out.println(key+":"+map.get(key));

              }

             

     4》  FIS/FOS文件流、BIS/BOS缓冲流、ISR/OSW、BR/PW、OIS/OOS

        

         文件流（节点流）：连接文件

         FileInputStream

         FileOutputStream

        

         缓冲流（处理流）：通过内部的缓冲区，提高读写效率

         BufferedInputStream

         BufferedOutputSteam

        

         字符转换流（处理流）：把字节数据根据特定的编码转化成字符

         InputSteamReader

         OutputStreamWriter

        

         字符缓冲流（处理流）：readLine可以一次读取一行字符

         BufferedReader

         字符打印流（处理流）：print,println可以把各种数据转化成字符串输出

         PrintWriter        

        

        

         对象流（处理流）：writeObject,readObject对象的序列化和反序列化

         ObjectInputStream

         ObjectOutputStream

        

         拷贝文件：

         FISfis = new FIS("src");

         FOSfos = new FOS("dest");

         BISbis = new BIS(fis);

         BOSbos = new BOS(fos);

         intb = -1;

         while((b=bis.read())!=-1){

              bos.write(b);

         }

         bis.close();

         bos.close();//必须关闭，需要bos.flush();

        

         写文本文件：

         FOSfos = new FOS("src.txt");

         OSWosw = new OSW(fos,"utf-8");

         osw.write("你好");

         osw.close();

        

         读文本文件：

         FISfis = new FIS("dest.txt");

         ISRisr = new ISR(fis,"utf-8");

         charc = (char)isr.read();

         isr.close();

        

        

         读文本文件,一次读一行：

         FISfis = new FIS("dest.txt");

         ISRisr = new ISR(fis,"utf-8");

         BRbr = new BR(isr);

         Stringline = br.readLine();

         br.close();

        

         将各种数据信息的字符串表示输出到文件中。

         FOSfos = new FOS("log.txt");

         OSWosw = new OSW(fos);

         PWpw = new PW(osw);

         pw.println(emp);

         pw.println(250);

         pw.println("hello");

         ...........................

        

        

         从控制台输入一行数据：

         BRbr = new BR(new ISR(System.in));

         Stringline = br.readLine();

        

         从socket中输入数据（文本）

         InputStreamis = socket.getInputStream();

         ISRisr = new ISR(is);

         BufferedReaderbr = new BufferedReader(isr);

        

        

         向socket中输出数据（文本）

         OutputStreamos = socket.getOutputStream();

         OSWosw = new OSW(os);

         PWpw = new PW(osw);

        

     5》  多线程和网络

     1.   线程和进程的区别           

         进程是操作系的多个任务（不同的内存）；线程是在一个进程中的多个任务（同一内存）

     2.   java语言中创建线程的方法

         //线程运行方法必须写到Thread的子类中

         publicclass MyThread extends Thread{

              publicvoid run(){....}

         }

         MyThreadt = new MyThread();

         t.start();

        

         //run方法可以写到任意的类中，只要实现Runnable接口就可以

         publicclass Some implements Runnable{

              publicvoid run(){...}

         }

         Threadt = new Thread(new Some());

         t.start();

        

        

         publiccalss BO{

              privateclass MyThread implements Runnable{

                   publicvoid run(){....

              }

              MyThreadt = new MyThread();

              t.start();

         }

    

     3.   线程的状态和相互转换

    

     4.   线程同步问题

         多个线程访问同一可变的对象

         访问的方法加琐（效率下降）synchronized

         publicvoid f(){

              ...   ...   ...

              synchronized(obj){

                   xxxxxx xxx

              }

              ...   ...   ...

         }   

     5.   线程安全API

         线程安全               线程不安全

         StringBuffer-------------------StringBuilder

         Vector*------------------------ArrayList

         Hashtable*---------------------HashMap

         Collections的方法对List和Map的同步