javase基础知识点，javase基础知识

javase基础知识点，javase基础知识

switch(必须为整型或字符型){
  case 1:
    break;
  case2:
    break;
  default:
}


(int)(math.random()*10)0_9


为什么分基本数据类型和对象（不是一切皆对象吗）
因为基本数据类型的包装类也为对象，基本数据类型存放在栈中，读写速度比堆快
为什么会有包装类呢，因为程序中某些数据可能会返回空值，用包装类其对象可以为null避免了异常，一般建议用包装类，虽然会牺牲一些转换效率，但是可以避免持久化数据时产生的一些异常


instanceof对象是否属于某种类的类型
Animal dog=new Animal();
boolean bool=(dog instanceof String);


构造器：当创建类的对象实例时调用，与类同名，无返回类型，在java中，每个类都必须至少有一个构造器（默认：方法体为空），在创建对象时初始化对象


栈内存：存储基本数据类型、对象引用
堆内存：new出来的数据——堆是栈的一部分，堆是内存快，




求绝对值：return((x>=0)?x:-x);


可以重载构造方法，可以使用者能够零活机动地实例化对象


如果被定义成静态，那么无论有多少个对象，静态成员变量只有一份内存拷贝，即：所有对象共享该成员变量，其作用域只在内部，生命周期贯穿整个程序
实例化对象可调用静态成员变量，类名.也可以，访问的都是同一个，且静态成员变量声明时最好初始化，否则默认值


静态成员方法：只能对静态成员变量进行操作，方法内无this引用




声明对象数组的方式如：Student[] stdAry=new Student[5];
  /*逐一为每个引用创建对象实例*/
  stdAry[0] = new Student("张三", 18);
  stdAry[1] = new Student("李四", 20);
  stdAry[2] = new Student("王五", 24);
  stdAry[3] = new Student("郑六", 21);
  stdAry[4] = new Student("田七", 19);


  for (int i = 0; i < stdAry.length; i++)
  {
    stdAry[i].display();//***************************
  }
}




继承：
解决了代码的重用问题。
自动传播代码
减少代码和数据的重复冗余度，并通过增强一致性来减少模块间的接口和界面，从而增强了程序的可维护性
1 父类中的构造方法不能被子类继承，即使它是public的
2 当实例化子类的对象时，必须先执行父类的构造方法，然后再执行子类的构造方法；
3 如果父类的构造方法执行失败，那么子类的对象也将无法实例化。


super：
用途1：在子类的构造方法中，super关键字可以显式地调用父类的构造方法，传递参数，super（实际参数）；且必须为第一条语句
用途2：如果父类和子类中有同名成员，在子类中默认访问是属于自己的那一个成员，super可以明确地指出要访问父类中的成员 super.成员名
public void fun()
  {
    num = 10;        //默认访问自己的成员
    super.num = 20;  //指定访问父类的成员
  }






抽象类：
有抽象方法的类一定是抽象类
public abstract class Shapes{
public abstract void publicraw();
}
抽象类不可以直接实例化，只可以用来继承；
抽象类的派生子类应该提供对其所有抽象方法的具体实现，如果子类如果没有覆盖且实现所有的抽象方法，那子类也必须是一个抽象类只能用于继承；
抽象类可以继承抽象类或非抽象类，单继承
抽象类和抽象方法不能被final修饰
构造方法和静态方法不可以修饰为abstract。
解释：被static修饰的方法在和没有static修饰的方法在内存中的位置不一样，被static修饰的方法属于类，不是给子类继承的
接口：
一个类可以继承一个父类，同时实现多个接口
接口只能用于实现implements
接口中所有方法默认为抽象方法
接口的实现类应实现所有抽象方法，否则将成为抽象类
java只支持单继承，却可以实现多个接口


final：
1、修饰变量：该变量就成为常量，且必须初始化
2、修饰方法：不能被子类重写
3、修饰类：无法被继承


类与类之间的关系：
1、是：继承关系
2、有：指一个类中包含了另一个类的对象，可以理解为类的嵌套


插入排序、冒泡排序——待补充






工具类
每个包装类都有一个静态的valueOf方法，用于将字符串转换成相应包装类的对象
public class LangDemo{
 public static void main(String[] args){
String str="120";
//如果转换失败，引发NumberFormatException异常
Byte objByte=Byte.valueOf(str);
Short objShort=Short.value0f(str);
Integer objInt=Integer.valueOf(str);
Long objLong=Long.valueOf(str);
System.out.println(objByte);
System.out.println(objShort);
System.out.println(objInt);
System.out.println(objLong);
}
}
除了Boolean类和Character类以为，其它的包装类都有静态的parseXxx方法，用于将字符串转换成相对应的原始数据类型值。
public class ParseTest {
  public static void main(String[] args) {
    String str = "116";
    //分别调用各个包装类的paseXxx方法对字符串进行转换，如果转换失败，将报异常
    int i = Integer.parseInt(str);
    short s = Short.parseShort(str);
    byte b = Byte.parseByte(str);
    long l = Long.parseLong(str);
    float f = Float.parseFloat(str);
    double d = Double.parseDouble(str);
    System.out.println(i);
    System.out.println(s);
    System.out.println(b);
    System.out.println(l);
    System.out.println(f);
    System.out.println(d);
  }
}


boolean isLetter(char ch) ——判断字符ch是否为英文字母
boolean isDigit(char ch) ——判断字符ch是否为0-9之间的数字
boolean isUpperCase(char ch) ——判断字符ch是否为大写形式
boolean isLowerCase(char ch) ——判断字符ch是否为小写形式
boolean isWhitespace(char ch) ——判断字符ch是否为英文字母
以上方法为静态方法
public class CharacterDemo {
  public static void main(String[] args) {
    char[] charArray = {'*', '7', 'b', ' ', 'A'};
    for (int i = 0; i < charArray.length; i++) {
      if (Character.isDigit(charArray[i])) {
        System.out.println(charArray[i] + "是一个数字。");
      }
      if (Character.isLetter(charArray[i])) {
        System.out.println(charArray[i] + "是一个字母。");
      }
      if (Character.isWhitespace(charArray[i])) {
        System.out.println(charArray[i] + "是一个空格。");
      }
      if (Character.isLowerCase(charArray[i])) {
        System.out.println(charArray[i] + "是小写形式。");
      }
      if (Character.isUpperCase(charArray[i])) {
        System.out.println(charArray[i] + "是大写形式。");
      }
    }
  }
}






String类
创建一个字符串对象之后，将不能更改
每当更改了字符串，就创建了一个新的字符串对象，原始字符串保持不变


int indexOf(int/String)搜索字符ch在当前字符串中第一次出现的索引，没有出现则返回-1
int lastIndexOf(int/String)搜索字符ch在当前字符串中最后一次出现的索引，没有出现则返回-1


char charAt(int index)用于指定位置提取单个字符，索引值必须为非负，返回类型为char，起始位置为0
String substring(int index)用于提取冲index指定的位置开始的字符串部分，起始位置为0
String substring（int begin，int end）用于提取始末之间的字符串，包含begin,不包含end
如果 start 与 end 相等，那么该方法返回的就是一个空串（即长度为 0 的字符串）。
如果 start 比 end 大，那么该方法在提取子串之前会先交换这两个参数。如果 start 或 end 为负数，那么它将被替换为 0。


String replace(char oldChar, char newChar)用于将调用字符串中出现oldChar指定的字符全部都替换为newChar指定的字符


String toUpperCase()返回当前字符串的全大写形式
String toLowerCase()返回当前字符串的全小写形式


StringBuffer类的常用方法
StringBuffer insert(int dex,x x)将x插入到索引为index的位置，x可以为任何类型的数据
int length()获得当前长度
void setCharAt(int index,char ch)使用 ch 指定的新值替换 index指定的位置上的字符
String toString()转换为字符串形式
StringBuffer reverse() 将当前StringBuffer对象中的字符序列倒置
StringBuffer delete(int start,int end)删除当前对象中从start位置开始直到 end 指定的索引 位置的字符序列
StringBuffer deleteCharAt(int index)将删除 index 指定的索引处的字符
StringBuffer replace(int start, int end, String str)此方法使用一组字符替换另一组字符。将用替换字符串从 start指定的位置开始替换，直到 end 指定的位置结束
append(String str) 末尾连接
public class StringBufferDemo {
    public static void main(String[] args) {
        StringBuffer strBuf = new StringBuffer("Java");
    
        strBuf.append(" Guide Ver1/");  //连接
        System.out.println(strBuf);
        strBuf.append(3);
        System.out.println(strBuf);


        strBuf.insert(5, "Student");    //插入
        System.out.println(strBuf);
    
        strBuf.setCharAt(20, '.');      //替换字符
        System.out.println(strBuf);
    
        strBuf.reverse();               //倒序
        System.out.println(strBuf);
    
        String str = strBuf.toString();
        System.out.println(str);
    }


JDK1.5以后，提供了一个新的字符缓冲区：StringBuilfer——非线程安全；提供了自动封解箱机制（包装类）


Math类
该类构造方法被修饰为private，所以不能被实例化
所有方法均为静态
该类被修饰为final，因此无子类


常用方法：
static int abs(int a)求a的绝对值
static double pow(double a,double b)求a的b次方幂
static double sqrt(double a)求a的平方根
static round(float a)a的四舍五入
static double ceil(double a) 向上取整
static double floor(double a)向下取整




Object类
Object类就是单根体系的根，即所有类的共同父类
常用方法：
boolean equals(Object obj)判断当前对象是否与参数obj（内容）相等，如果有必要，应该在自定义的类中覆盖该方法
String toString()返回当前对象的字符串表示，如果有必要，应该在自定义的类中覆盖该方法
protected void finalize()
throws Throwable当前对象被垃圾回收时调用此方法（类似于C++的析构函数），但无法确定具体何时调用


java.lang包是Java中最基础的一个包，也是唯一一个无需显示声明就默认导入包；


String明明可以执行串联操作，为什么说是静态的不可改变的呢？
String的确可以执行串联操作，String s1=”abc”;String s2=”123”;s1=s1+s2;代码运行后s1的确也变成了”abc123”,然而改变的却不是原始的字符串对象，JAVA会新建一个字符串，把结果放到新建的字符串对象中，并将新字符串的引用传递给s1,因此，现在的s1跟以前的”abc”字符串已经不存在任何关系了。




Date类
Date类的常用方法：
boolean after(Date when)如果当前日期对象在when指定的日期对象之后，返回true，否则返回false
boolean before(Date when)如果当前日期对象在when指定的日期对象之前，返回true，否则返回false
void setTime(long time)设置日期对象，以表示自1970年1月1日起的指定毫秒数
boolean equals(Object obj)如果两个日期对象完全相同，返回true，否则返回false
String toString()返回日期的格式化字符串，包括星期几
public class DateDemo
{
  public static void main(String[] args)
  {
    Date date = new Date();  //获得当前的系统日期和时间
    System.out.println("今天的日期是：" + date);


    long time = date.getTime();  //获得毫秒数
    System.out.println("自1970年1月1日起以毫秒为单位的时间(GMT):" + time);


    //截取字符串中表示时间的部分
    String strDate = date.toString();
    String strTime = strDate.substring(11, (strDate.length() - 4));
    System.out.println(strTime);
    strTime = strTime.substring(0, 8);
    System.out.println(strTime);
  }
}


Calendar类也是用来操作日期和时间的类，但它可以以整数形式检索类似于年、月、日之类的信息；
Calendar类是抽象类，无法实例化，要得到该类对象只能通过调用getInstance方法来获得；
Calendar对象提供为特定语言或日历样式实现日期格式化所需的所有时间字段。
public class CalendarDemo
{
  public static void main(String[] args)
  {
    //创建包含有当前系统时间的Calendar对象
    Calendar cal = Calendar.getInstance();    
    //打印Calendar对象的各个组成部分的值
    System.out.print("当前系统时间：");
    System.out.print(cal.get(Calendar.YEAR) + "年");
    System.out.print((cal.get(Calendar.MONTH) + 1) + "月");
    System.out.print(cal.get(Calendar.DATE) + "日 ");
    System.out.print(cal.get(Calendar.HOUR) + ":");
    System.out.print(cal.get(Calendar.MINUTE) + ":");
    System.out.println(cal.get(Calendar.SECOND));
    //将当前时间添加30分钟，然后显示日期和时间
    cal.add(Calendar.MINUTE, 30);
    //返回与调用对象具有相同时间的Date对象
    Date date = cal.getTime();
    System.out.println("将当前时间添加30分钟后的时间：" + date);
  }
}
日期格式化
Date nowTime=new Date(); 
System.out.println(nowTime); 
SimpleDateFormat time=new SimpleDateFormat("yyyy MM dd HH mm ss"); 
System.out.println(time.format(nowTime)); 




Random类
专门用来生成随机数
常用方法：
int nextInt()从随机数生成器返回下一个整型值






集合
集（Set）不允许重复
列表（List）区别顺序
映射（Map)键值对
Java集合中只能保存引用类型的数据，实际上存放的是对象的引用，而非对象本身
Collection接口:
Set/List
boolean add(Object o)
boolean remove(Object o)
int size()
Object get(int index)返回指定索引位置的元素
boolean isEmpety();
boolean contains(Object o)
int indexOf(Object element)判断element在ArrayList对象中是否存在，存在返回对应的索引，否则返回-1
Object[] toArray()将当前集合中所有元素转换成一维数组
void clear() 删除集合对象中的所有元素
void removeAll(Collection c) 从集合中删除集合c中的所有元素


ArrayList类：
ArrayList是长度可变的对象引用数组，称为动态数组；
随着元素的添加，元素数目的增大，数组容量也会随之自动扩展；
访问和遍历数组元素时，ArrayList的性能优越；


LinkedList类
与ArrayList相比，如果需要频繁地添加和删除元素，LinkedList的性能更加优越；
LinkedList类继承了AbstractSequentialList类，并实现了List接口；
Vector类：线程同步


HashMap类：
HashMap以键值对的形式存储元素；
对于HashMap来说，不存在索引，也就是说不可以通过索引来访问元素，只能通过键去访问值，如要快速检索元素的话，HashMap性能优越；
由于没有索引，所以HashMap中元素的存放是没有顺序的；
HashMap类继承了AbstractMap类，并实现了Map接口。
区别：
Hashtable:同步的，线程安全的，键值不允许为null
HashMap：非线程同步；允许键值为null


ArrayList类继承了AbstractList类并实现了List接口。




数组
数组是一个变量，存储相同数据类型的一组数据
如何使用数组：
1、声明数组：int[] a或int a[];
2、分配空间：a=new int[5];
3、赋值：a[0]=8;
4、处理数据：a[0]=a[0]*10;
边声明边赋值：
1、int[] b={100,30,……｝;
2、int[] b=new int[]{32,34,56};
动态从键盘录入信息并赋值
Scanner input = new Scanner(System.in);
for(int i = 0; i < 30; i ++){
     score[i] = input.nextInt();
}
利用数组求平均值：
int [ ] score = {60, 80, 90, 70, 85};
int sum = 0;
double avg;
for(int index = 0; index < score.length; index++){
     sum = sum + score[index];
}
avg = sum / score.length; 
创建数组并赋值的方式必须在一条语句中完成
int[ ] score = new int[5];
score2 = {60, 80, 90, 70, 85}; 
编译出错


求最大值：
       //计算成绩最大值
        max = score[0];
        for (int index = 1;index < 5;index++) {
              if (score[index] > max) {
                      max = score[index];
              }
        }
        System.out.println("本次考试的五位学生的最高分是： " + max);


排序：
       import java.util.*;   //导入包
       ……
       int[ ] score = new int[5];
       Scanner input = new Scanner(System.in); 
       System.out.println("请输入5位学员的成绩：");
       for(int i = 0; i < 5; i++){
score[i] = input.nextInt();  //依次录入5位学员的成绩
        }
       Arrays.sort(score);    //排序-对数组进行升序排列
       for(int index = 0; index < score.length; index++){
              System.out.println(score[index]);   //输出结果
        }


有一列乱序的字符，‘a’,‘c’,‘u’,‘b’,‘e’,‘p’,‘f’,‘z’，排序并按照英文字母表的逆序输出
char list[ ] = {'a','c','u','b','e','p','f','z'};
Arrays.sort(list);
for (int i = list.length - 1; i >= 0; i-- ) {
      System.out.println(list[i]);
}




字符串
equalsIgnoreCase比较时忽略大小写
concat（）字符串连接
String s = new String("你好，");
String name = new String("张三！");
String sentence = s.concat(name);
System.out.println(sentence);
输出结果：你好，张三！


Queue
  队列，jdk1.5版本新增接口，Queue实现了“先进先出”（FIFO）的存储结构。Queue是Collection的子接口，具有所有集合基本操作，除此之外，Queue还提供了一些新的插入、提取、查询等方法。


LindedList
链表，其不仅实现了List接口，还实现了Queue接口，可以说链表同时也可以作为一个队列对象使用，使用方法与ArrayLisproperties文件中写值




Properties类
Properties类是Hashtable类的子类，所以也间接地实现了Map接口。在实际应用中，常使用Properties类对属性文件进行处理
常用方法：load（）；加载文件；
getProperty（key）通过key值获得对应的value值
setProperty（String key，String value）给properties文件中写值。


Collections排序方法
public class GenericsList {
public static void main(String[] args) {
User user4= new User(11); // 创建用户对象
User user1 = new User(14);
User user2 = new User(13);
User user3 = new User(9);
List<User> userList = new ArrayList<User>(); // 创建集合对象，存放用户对象
userList.add(user4);
userList.add(user1);
userList.add(user2);
userList.add(user3);
for(User u:userList){
System.out.println(u.getUserAge());
}
Collections.sort(userList);//调用排序方法
 for(User u:userList){
System.out.println(u.getUserAge());
}
}




IO流
File类
//在当前目录下创建一个与aaa.txt文件名相关联的文件对象
File f1 = new File("aaa.txt");
//指明详细的路径以及文件名，请注意双斜线或用反斜杠
File f2 = new File("D:\\Java\\Hello.java");
//指明详细的路径以及目录名，请注意双斜线
File f3 = new File("D:\\Java");


File类的常用方法
boolean exists()判断文件是否存在
boolean is File()判断是否为文件
boolean isDirectory()判断是否为目录
String getName()获得文件的名称
String getAbsolutePath()获得文件的绝对路径
long length()获得文件的长度
boolean createNewFile() throws IOException创建文件，有可能抛除IOException异常，必须捕捉
boolean delete()删除文件


File类的遍历
String[] list()将目录下的子目录及文件的名字，返回到String数组中
File[] listFiles()将目录下的子目录及文件的实例返回到File数组中


字节流与字符流
InputStream和OutputStream的子类都是字节流
节点流中常用类
   -字节输入流 FileInputStream
  -字节输出流 FileOutputStream
  -字符输入流 FileReader
  -字符输出流 FileWriter


处理流中常用类
  -缓冲字节输出流 BufferedOutputStream
  -缓冲字节输入流 BufferedInputStream
  -缓冲字符输入流 BufferedReader
  -缓冲字符输出流 BufferedWriter
字符缓冲输出流，把写入的数据先写入到内存，再使用flush()方法将内存数据刷到硬盘上。在使用字符缓冲输出流时，一定先flush(),然后再close(),避免数据的丢失。


基本数据类型和引用数据类型作为参数时的区别
如果参数是基本数据类型，传递的是真正的数据值
如果参数是引用数据类型，传递的是地址


public class Test{


    public void say(int num){
        num = 20;
        System.out.println(num);
    }
    public static void main(String[] args){
        Test  test  =  new Test();
         int num = 10;
         test.say(num);
         System.out.println(num);
    }
}
打印结果为：20，10
结论：基本数据类型作为参数，在方法内部改变参数的值，不会影响到外部
打印结果为：20，20
结论：引用数据类型作为参数，在方法内部改变参数的状态，会影响到外部
public class Test{
    public void  say(StringBuffer  strb){
        strb = new  StringBuffer(“bbb”);
        strb.append(“ccc”);
        System.out.println(strb.toString());
    }


    public static void main(String[] args){
        Test  test  =  new Test();
        StringBuffer strb = new StringBuffer(“aaa”);
        test.say(strb);
        System.out.println(strb.toString());
    }
}
结果：aaaccc，aaa
结论：引用数据类型作为参数，在方法内部改变了引用对象，不会影响到外部




class T{
    int num = 10;
}
public class Test{
    public void  say(T t){
        t = new  T();
        t.num = 20;
        System.out.println(t.num);
    }


    public static void main(String[] args){
        Test  test  =  new Test();
        T t = new T();
        test.say(t);
        System.out.println(t.num);
    }
}
结果：20，10
结论：引用数据对象作为参数，在方法内部改变了对象，不会影响到外部


冒泡排序：
for(int i=1;i<5;i++){
 for(int j=4;j>=i;j--){
  if(num[j]<num[j-1]){
   int temp=num[j-1];
   num[j-1]=temp;
  }
 }
}