corejava

环境变量

  JAVA_HOME : jdk安装目录

  PATH : ;%JAVA_HOME%\bin  

  CLASSPATH : .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;  //指示编译器和JVM,到哪去找所需要的类

package xx;

import java.util.*;

注释

  1)//  单行注释

  2)/*  */  多行注释

  3)/**  */  多行注释,配合JavaDoc工具使用

命名规范

  包名:全小写

  类名:单词首字母大写

  变量名/函数名:首单词小写,后面的单词首字母大写

  常量名:全大写

数据类型

对象类型

简单类型

  bute  1B  -128~127

  short  2B  -32768~32767

  int   4B  -2147483648~2147383647

  long  8B  -263 ~ 263-1

  float  4B

  double  8B

  char  2B

  boolean  true / false

&  |  //非短路  依然进行后面的判断 例:a>b & c<d  一定进行c<d的判断

&&  ||  //短路  满足条件不进行后面的判断

流程控制

  1)if(){

     }

     else{

     }

  2)switch(i){      //整型表达式 byte short int char

      case 1:xx;break;

      case 2:xx;break;

      default:xx;

     }

  3)while(){

     }

  4)for(;;){

    }

函数

  声明:public static 返回值类型 函数名(参数表)

  实现:{}  必须和声明一致(主要指返回值类型)

  调用函数:函数名(实际参数);

数组

  int[] a;   int a[];

对象

  属性:有什么

  方法:能做什么

  各司其职  对象应该保持简单性

  弱耦合性  对象和对象之间的联系应该尽量弱化

  可重用性  

  可扩展性

类  class

  对象共性的抽象;对对象的认识;类是对象的模板

  属性:实例变量

  1)有默认值  数值类型:0  布尔类型:false  对象类型:null

  2)作用范围:至少是全类内部

  3)命名冲突时,局部优先

  方法:

  方法的声明:对象能做什么

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

  方法的实现:对象怎么做

重载

  1)参数个数不同

  2)参数类型不同

  3)参数类型排列不同

构造方法

  1)没有返回值类型

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

  3)不允许手工调用,构造过程中自动调用一次

封装

  public  公开

  private  私有  只能在本类内部访问

  属性私有 提供公开的setxxx/getxxx用来访问属性

  方法私有 只给自己调用

继承

  父类:子类的共性抽象出来

  所有子类能够访问的父类属性和方法,即是子类从父类中继承到的属性和方法

  private  私有  不能继承

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

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

  public  公开  可以继承

  构造方法不能继承

  方法的覆盖

    返回值类型 方法名 参数表相同,访问修饰符相同或更宽

多态

  子类对象可以看做是父类的对象

  子类对象可以放入父类引用

  1)对象类型不变

  2)只能对引用调用起引用类型中声明的方法

  3)运行时,根据对象实际类型找子类覆盖之后的方法

  子类引用赋值给父类引用 可以直接赋值

  父类引用赋值给子类引用 必须强制类型转换 保证编译通过

  运行时可能发生类型转换异常

  在强制类型转换之前,可以用instanceof判断,避免类型转换异常  //引用 instanceof 类名

  作用

    将不同子类对象统一看作父类对象,屏蔽不同子类的差异

  多态的常见用法

  1)多态用在方法参数上,形参可以是父类引用,实参可以传子类对象  //m(A a): 可以用A的任何子类对象作为参数

  2)多态用在方法的返回值上  // A m():m方法完全可以返回A的某个子类对象

abstract 抽象的  extends继承接口

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

  方法  抽象方法 只有声明 没有实现

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

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

  利用abstract,可以把方法声明抽象到父类中,而方法实现留在子类 更好的体现“共性放在父类”原则

修饰符组合:

  private static final 均不能喝abstract联用

interface 接口  implements实现接口

new 接口(){};

  1)所有的属性都是公开静态常量

  2)所有方法都是公开抽象方法

  3)没有构造方法

  接口之间可以多继承  interface IA extends IB,IC{} 

  一个类在继承另外一个类的同时,还可以实现多个接口  class Impl extends ClassE implements IA,ID{}

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

  解耦合的工具 标准

  把标准的使用者和标准的实现者分离

接口的回调

  在定义接口之后,先有接口的使用者,后有接口的实现者 使用者通过接口调用实现者中的方法

内部类

  1)内部类可以访问外部类的私有成员,而不破坏封装

  2)接口公开,接口的实现类作为内部类隐藏起来,强制弱耦合

匿名内部类

  new 接口(){

  };  //实现了接口的没有名字的内部类对象

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

Object 类   Java中所有类的父类

  1 Object o;  o中可以装任何对象

  2 Object类中的方法 是所有对象都具有的方法

1)finalize():由垃圾收集器在回收垃圾对象时,最后调用

2)getClass():返回对象的实际类型

3)toString():返回对象的String形式 打印一个对象就是打印这个对象的toString方法的返回值

4)boolean equals(Object o):判断this和o内容是否相同

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

集合框架

集合:容器 一个对象,用来储存其他多个对象

Collection    //父接口

特点:元素是Object

List    //子接口

  特点:元素有顺序 可以重复

  实现类:

    1)ArrayList 用数组实现  轻量级  线程不安全  查询快  增删慢

    2)Vector 用数组实现  重量级  线程安全

    3)LinkedList 用链表实现  查询慢  增删快

Set    //子接口

  特点:元素无顺序 不可以重复

  遍历:迭代遍历

    Iterator it = set.iterator();

    while(it.hasNext()){

      Object o = it.next();

      System.out.println(o);

    }

  实现类:

  HashSet

  把自定义对象放入HashSet,为保证元素不重复 必须:

  1)覆盖hashCode() 保证相同对象返回相同int

  2)覆盖equals() 保证相同对象返回true

Map

  特点:元素有键值对组成 其中键唯一 值可以重复

  方法:

  put(Object k,Object v):把k-v这个键值对放入Map

  get(Object k):返回Map中对应的v

  实现类

  1)HashMap:1.2  允许用null作为key或者value

  2)Hashtable:1.0  不允许null作为key或者value

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

泛型  模板编程

不同泛型之间不能相互赋值

泛型的通配符:

? :任何类型

? extends Number:Number类或Number的任何子类

? super Number:Number类或Number的任何父类

? extends Comparable:任何实现Comparable接口的类

  泛型方法:

  <T extends Number&Comparable>:T既是Number的子类,又实现Comparable接口

  泛型类:

  泛型技术应用在集合框架中:实现类型安全的集合

  泛型:预定集合中的元素类型  

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

Scanner sc = new Scanner(System.in);

int i = sc.nextInt();

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

异常处理 容错性

异常的分类

Throwable  //所有异常类总的父类

  Error  错误  //子类

  Exception  异常  //子类

  1)已检查异常

    不可避免  必须处理  

  2)RuntimeException  未检查异常

    可以避免  可处理可不处理

throw:动作,抛出一个异常 将异常对象作为方法的返回值返回 等同于return语句

异常的处理:

  1)throws  声明抛出

  2)try-catch 捕获异常

  try-catch-finally

  try{  }

  catch(IOException e){  }

  finally{  }

方法的覆盖:

  访问修饰符相同或更宽 方法名,参数表,返回值类型 相同

  子类不能比父类抛出更多的异常

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

多线程

进程:OS中并发的一个任务

CPU分时间片  宏观并行  微观串行

线程:在一个进程中,并发的一个顺序执行流程

线程的组成:

  1)CPU

  2)Data  堆空间共享 栈空间独立

  堆空间:存储对象(存储实例变量)

  栈空间:存储局部变量

  3)Code  由程序员指定

  继承Thread类或者实现Runnable接口

  一个Thread对象代表一个线程

线程的同步:

  当多线程并发访问临界资源(同一个对象)时,如果破坏了原子操作(不可分割的操作),就会造成数据不一致

  synchronized(o){}:对o加锁的同步代码块

  任何对象都有一个互斥锁标记,用来分配给线程

  只有难道对象锁标记的线程,才能进入对该对象加锁的同步代码块

  线程退出同步代码块,会释放相应的锁标记

同步方法:

  在整个方法的范围内,对当前对象加锁

  只有拿到对象锁标记的线程,才能调用该对象的同步方法

线程间通信:等待-通知

任何对象都有一个等待队列,用来存放线程

t1:o.wait()必须放在对o加锁的同步代码块中.t1会释放其拥有的所有锁标记;同时t1会阻塞在o的等待队列中

t2:o.notify()/notifyAll()必须放在对o加锁的同步代码块中,从o的等待队列中释放一个/全部线程

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

java.io.File  File对象代表磁盘上的一个文件或者目录

createNewFile():创建新文件

mkdir():创建新目录

delete():删除

exists():文件对象所代表的文件(或目录)是否存在

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

I/O流

按照数据方向:输入流/输出流

按照数据单位:字节流/字符流

按照流的功能:节点流/过滤流

字节流:以字节为单位,可以出来一切数据

字符流:以字符为单位,只能处理文本数据

节点流:实际传输数据的流

过滤流:给节点流增强功能

InputStream/OutputStream 字节流的父类

FileInputStream/FileOutputStream 文件字节流 节点流

  write(int a):把字节a写出去

  write(byte [] bs):把字节数组bs全部写出去

  write(byte [] bs,int off,int len):把bs的一段写出去

  int read():从文件中读一个字节 返回-1为结束

  int read(byte[] bs):从文件中读多个字节,读满bs 返回值为实际读到的字节数 以-1为结束

  int read(byte[] bs,int off,int len):从文件中读多个字节,放入bs的一段。返回值为实际读到字节数,以-1为结束

1.创建节点流  FileOutputStream fos = new FileOutputStream("1.dat")

2.封装过滤流  BufferOutputStream out = new BufferOutputStream("fos")

3.读/写数据   out.write("A")

4.关闭流    out.close()    

out.flush()  //清除缓冲区

DataInputStream/DataOutputStream 直接读写8种基本类型和String

BufferedInputStream/BufferedOutputStream 缓冲

PrintStream:写8种基本类型 缓冲

---------------------------------------

编码解码

String str = "字符串用例";

byte[] bs1 = str.getBytes("GBK");

String str2 = String(bs1,"Big5");

System.out.println(str2);

--------------------------------------

字符流

Reader/Writer 字符流父类

FileReader/FileWriter  文件字符流 节点流

BufferedReader/BufferedWriter  缓冲流 过滤流  BufferedWriter 现在被PrintWriter代替

InputStreamReader/OutputStreamWriter  桥转换,字节流转换字符流

  OutputStream fos = new FileOutputStream("poem.txt");

  Writer ow = new OutputStreamWriter(fos);

  PrintWriter out = new PrintWriter(ow);  也可以 PrintWriter out = new PrintWriter(fos);

  还可以直接 PrintWriter out = new PrintWriter("poem.txt");//JDK5.0以后

--------------------------------------

对象序列化:将对象通过流传输  

ObjectOutStream/ObjectInputStream

类对象实现Serializable接口才能放在流上传输

FileInputStream fis = new FileInputStream("student.dat");

ObjectInputStream in = new ObjectInputStream(fis);

Student o1 = (Student)in.readObject();

Student o2 = (Student)in.readObject();

in.close()

System.out.println(o1);

System.out.println(o2);

关键字:transient   //只能修饰属性,修饰的属性叫临时属性,不会参与序列化,

-------------------------------

实现Cloneable接口,可以克隆对象

覆盖克隆方法
public Object clone(){  //修饰符原protected覆盖成public

  try{

    return super.clone()

  }catch(CloneNotSupportedException e){

  e.printStackTrace();

  return null;

  }

}

s.setAge(19);  

Object o = s.clone(); 或者 Student s2 = (Student)s.clone();

out.writeObject(o); 或者out.writeObject(s2);

out.close();

通过使用克隆的方式,同一个流换个地址,解决同一个对象多次系列化出问题

-------------------------------

 

时间: 2024-10-05 06:40:28

corejava的相关文章

corejava ---- 对数据库访问能力 2

驱动 ojdbc1.4.jar 1 加载数据库驱动 -->注册驱动 2 建立连接 3 创建一个 statement 4 到客户端执行SQL语句 5 处理返回结果集 (ResultSet) 6 取消联结  释放资源 打开端口号 1521 1 加载驱动  三种方式 Class.forName("oracle.jdbc.driver.OracleDriver"); 2 Driver d = new oracle.jdbc.driver.OracleDriver-->运行时 3 D

不该被忽视的CoreJava细节(四)

令人纳闷的数组初始化细节 这个细节问题我很久以前就想深入研究一下,但是一直没有能够抽出时间,借这系列文章的东风,尽量解决掉这个"心头病". 下面以一维int数组为例,对数组初始化方式进行分类. 1) int[] a = new int[2]; a[0] = 1; a[1] = 2; 2) int[] a = new int[]{1, 2}; 3) int[] a; a = new int[]{1, 2}; 4) int[] a = {1, 2}; 这四种初始化方式都是合理的. 但有的时

CoreJava学习笔记1-基本概念、对象和类

一.    java的基本程序设计结构 (一)   java共有8种基本类型:4种整型,2种浮点类型,1种char,1种boolean. 1)       4种整型:byte(1).short(2).int(4).long(8). 2)       int最常用,byte和short常用在底层的文件处理或者需要控制占用存储空间量的大数组. 3)       浮点类型:float(4).double(8).Float后缀F,不加后缀默认为double(D). 4)       char类型表示单个

CoreJava笔记之JavaBean、静态方法static和final

记住两句话: 1.属性是静态绑定到变量类型: 2.方法是动态绑定,由最终对象的方法决定 =============================== 关于JavaBean: 1.不是语法规则,是习惯性编程规范,用这个规范写的类使用方便: 2.规范: a.必须有包: b.是一个java类,具有无参数构造器: c.有用getXxx() 和setXxx()声明的Bean属性. 如:getName()和setName(String n)声明的Bean属性为:name,与是否有实例变量name无关. b

CoreJava基础之一构造器

类的基本语法: 修饰词 class 类名{ 修饰词 类型 属性名: } 实例:public class Book{ int id; String name; String[] authors ={"佚名"}; double price; String isbn;//书号 } 对象Object,类和引用Reference 对象:是类的具体实例: 引用:是指具体对象的句柄,相当于自然语言的代词 引用和对象的关系:引用本身不是对象,引用关联了一个具体的对象: 引用可能指空: 简单的叙述事物时

CoreJava知识点1

一.基础 1.Java最大特点:开源open 2.J2EE由表示层.业务层.数据层组成 3.环境变量:javahome:JDK的安装路径 path:%javahome%\bin  ——虚拟机 执行命令的路径 classpath:%javahome%\lib  ——字节码文件的路径 4.JVM工作:类加载—字节码校验—解析器—成为机器能执行的机器语言 二.打包 1.强行打包:javac -d  . Hello.java 2.jar打包:               解包:jar zxvf File

CoreJava笔记之线程

程序,进程和线程程序:没有执行的指令序列和相关的数据的集合(如:qq.exe) 如:磁盘上的可执行命令进程:正在执行的程序,进程占用资源(CPU,Memoary,IO)线程:是进程中并发执行的过程(共享进程资源) 同步:步调一致的顺序执行,如:上公交车,一个一个的上异步:步调不一致的同时执行,如:大家一起上卡车 线程:名称->类 Thread 类中包含一个方法 run() 这个方法就是独立运行的过程 Thread 类中还包含方法 start() 用来启动独立运行的run() 创建一并启动个线程:

corejava基础问题

1.同一个文件里是否可以有两个public类? 答:不能,同一个源文件如果有多个公共类,那么编译器就找不到应该执行的main方法了.当有一个public类,源文件名必须与之相同,否则无法编译. 2.在main方法内是否可以调用一个非静态方法? 答:main方法是静态方法,静态方法可以在没有对象实例的时候直接调用,但是因为没有对象实例,所以不能调用非静态方法.解决办法:new一个对象,然后调用这个对象的方法,或者将这个方法改为static方法. 3.静态方法是否可以调用一个非静态全局变量? 答:静

java面试题之coreJava

---恢复内容开始--- 1. String s = new String("123456789");System.out.println(s.substring(2,6)); System.out.println(s.substring(7)); 结果: 3456(从下标2开始到下标6结束) 789(单个参数为从7起始下标到结束截取) 2. public class TestS { void dosomg(){ private String name=""; in