java基础总结_java input.nextint

                                                 java基础

首先从流程控制讲起，我们常用的流程控制有

If..else  switch  for  while  for(int a: arr)

 

输出与输入

输出：System.out.print();  快捷键 syso (Alt+/)

输入：Scanner input = new Scanner(System.in);

Int a = input.nextInt();这里需要注意的是nextLine()接收时是接收一行

 

方法:我要讲的是构造方法、方法的重载、方法的重写以及方法的动态参数

构造方法：

①方法名字必须和类名相同

②方法没有返回值，且不能有void

③方法可以带多个参数

方法的重载：

①方法的名字相同

②参数的个数不同

③参数的类型不同

方法的重写：

子类的方法和父类的方法一样，包括参数类型，参数个数以及返回值

返回值类型是引用类型，可以是父类方法返回类型的子类或间接子类。

方法的动态参数：

①一个方法最多只能有一个动态参数

②动态参数只能放在参数的最后面

Fangfa(int a,String... s)  其中String... s相当于一个字符串数组

 

数组:我们采用类似 int[] a = {1,2,3}; int[] a = new int[4];二维数组:int[][] arr = new int[3][4];这种方式

 

数组中最重要的是数组的扩容：我们采用这种方式①新定义一个数组newArr

②将原数组的值复制到newArr③改变原数组的指针指向新数组arr=newArr。

事实上我们有个很简便的方法就是使用arr = Arrays.copyOf(arr,length);

 

其次是数组的排序：作为Java程序员，首先应该掌握的是冒泡排序

即 for(int i=0;i<arr.length-1;i++){

For(int j=0;j<arr.length-i-1;j++){

}

}

选择排序。。。

我们最常用的还是Arrays.sort(arr)这种排序方法

 

封装、继承与多态：

封装：即把属性用private修饰，然后给所有属性提供set和get方法

那为什么要封装？封装其实是为了控制你的传输值以及接收。形如我在set里增加判断语句，亦或在get里增加语句。

继承：如Animal 是 dog 的父类，那么dog就继承了animal的所有属性以及方法（当然私有属性是不能被继承的） 关键字：extends

多态：Animal an = new dog();

new谁，执行谁。但是不能使用子类扩展的方法和属性。子类没有的方法父类可以调用。

多态的好处：增加扩展性

//注意：形参是Animal a，用动物接收。到时候左边是 Fu f,右边是Zi z，Fu f= Zi z

public static void feedAnimal(Animal a){  //工具类，方法就写成static的，然后直接在测试类：工具类名.方法 使用。

        a.eat();   //成员方法：运行看右边：各子类的。（ 不然干嘛方法重写）

        a.sleep();

}

 

强制转换:

①必须是继承关系

②目标类型大于实际类型

 

向上面的多态，如果我想用子类的方法怎么办呢？

①我们可以直接使用dog d = new dog()的方式

②使用强制转换animal a = new dog(); dog d = (dog)a;

 

关于instanceof 判断对象是否属于某一类型

Boolean boo = t instanceof ta;

 

三个关键字：This,super,final关键字

This:指当前对象的引用，使用this() 掉用构造方法时只能在第一行调用

Super:指当前对象的直接父类的引用

Final:

1、final可以修饰变量（局部变量，成员变量）

1）用final修饰的变量只能赋值一次，相当于常量；

2）final修饰成员变量时，必须赋值（用定义初始化或构造函数初始化都行）；

3）final修饰成员变量时，每个对象的这个属性都只能赋值一次；

4）final修饰的函数，不能被重写；

5）final修饰的类不能被继承

 

Static关键字：

①使用类名点的方式调用

②如果一个类里面有静态属性，不管创建了多少个类的对象，静态变量同时指向的同一个静态变量（类变量）。

③非静态成员里面可以访问静态和非静态的

④静态方法中不能使用this

⑤静态方法里面不能调用非静态变量和非静态方法

⑥static方法不能重写

注意有static和final一起修饰的时候必须先赋值

 

运行过程：父类static->子类static->父类属性->子类属性->父类构造方法->子类构造方法

 

抽象类：关键字（abstract）

①抽象类的特点（可以用于声明，但不允许创建对象）

②被子类继承，从而创建子类对象

③抽象类里面可以有普通类里面所有的成员

 

抽象方法

①拥有抽象方法的类必须是抽象类

②抽象方法由子类重写，子类必须重写抽象类的所有抽象方法，否则，子类必须为抽象类。

③抽象方法，只有定义，没有方法体，一个抽象类可以有多个抽象方法。

 

接口：（一个特殊的抽象类。）

里面所有的方法都是公有的抽象方法,Jdk1.8版本之后可以有默认方法

好处：增加代码程序的通用性

①接口不能有构造方法和普通方法（不能有方法体）

②接口中，所有的方法都是public abstract类型（除了默认方法）

③接口里面的属性都是 public static final 的变量

接口的实现（类的继承）implements

重写接口所有方法

 

一个接口可以继承多个接口

接口不能继承类

一个类可以实现多个接口

一个类可以继承一个类的同时实现多个接口

 

包装类之间的转换：

①基本类型 -> 包装类 Integer a2 = new Integer(a1);

②包装类 -> 基本类型 int a1 = a2.intValue();

③基本类型 -> 字符串 String s = a1+””; String s = new String(a1);

④字符串 -> 基本类型 int a1 = Integer.parseInt(s);

⑤字符串 -> 包装类   Integer a2 = Integer.valueOf(s);

⑥包装类 -> 字符串   String s = a2.toString();

 

常用字符串的方法：

①boolean contains(CharSequence s) 是否包含该字符串

②String sbuString(int beginIndex, int endIndex) 提取子字符串

③char charAt(int index) 返回指定索引处的字符

④int compareTo(String anotherString) 按字典顺序比较两个字符串

⑤boolean endsWith(String suffix) 测试此字符串是否以指定的后缀结束

⑥boolean equals(Object anObject) 将此字符串与指定的对象比较

equalsIgnoreCase

⑦int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引

⑧int lastIndexOf(int ch)返回指定字符在此字符串中最后一次出现处的索引

Int lastIndexOf(String str)

⑨int length() 返回此字符串的长度

⑩boolean startsWith(String prefix) 测试此字符串是否以制定的前缀开始

⑾String toLowerCase() 转换为小写

⑿String toUpperCase() 转换为大写

⒀String trim() 去除空白

 

String是不可变的。

StringBuffer 线程安全，可变

StringBuilder 线程不安全，可变

更多内容，请参考API文档

 

内部类

 

泛型

 

集合：

List集合 特点：有序、可重复

ArrayList 底层采用数组实现（适合于查询要求快）

 线程不同步，线程不安全

 List里面判断是否包含某个对象，要求对象必须要重写equals方法

List排序 调用comparable接口的compareTo()方法

Collections.sort();

LinkedList 底层采用链表结构实现（适合于增删改操作频繁）

  线程不同步，线程不安全

Vector 底层使用数组实现

  线程同步，线程安全

 

ArrayList的主要方法：

①Add(E e);增加

②Add(int index,E element)插入

③Set(int index,E element)替换

④Contains(Object o)查看是否包含此元素

⑤Get(int index)获取指定位置的元素

⑥Clear()清除所有

⑦remove(int index)删除指定下标的元素

⑧size()获取集合大小

⑨isEmpty()判断是否为空

 

Set集合 特点：不可重复，无序

主要掌握HashSet 的存储过程：

①首先调用对象的hashCode()方法

②当发现hashCode编码相同时，进入equals方法判断是否返回true,如果为true,则对象不加入，否则加入。

 

Map集合 特点：键值对应（键不能重复，值可以重复）

主要掌握HashMap和TreeMap（都可以有空值和空键，线程都不安全）

 

HashMap对key的自动去重，利用的是hashCode方法和equals方法

TreeMap自动的对键进行排序，通过Comparable接口过滤重复排序

 

异常：

Java异常处理方式：

Throw 人为创建一个异常（如：throw new numberToBigException(“数字太大”);）

Throws 抛出给调用者处理

Try catch finally 自己处理

 

自定义异常注意事项：

①Public class numberToBigException Extends Exception

②添加两个构造方法，一个无参，一个带有String

③用system.out.println(e.getMessage)输出信息

 

文件： File file = new File(Path);

字节流：

InputStream    OutputStream

 

FileInputStream FileOutputStream

InputStream in = new FileInputStream(file);

 

方法：

①int read(byte[] b)从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。

②int read(byte[] b,int off,int len);

从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。

③int available()

返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。

④void write(byte[] b)

将 b.length 个字节从指定的 byte 数组写入此输出流。

⑤void write(byte[] b, int off, int len)

将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

 

对象流：

ObjectInput ObjectOutput

 

ObjectInputStream ObjectOutputStream

ObjectInputStream objIn = new ObjectInputStream(in);

 

方法：

①readObject();从 ObjectInputStream 读取对象。

②writeObject();将对象写入底层存储或流。

 

对象序列化：对象序列化必须要实现 Serializable接口

 

字符流：

Reader Writer

InputStreamReader ir = new InputStreamReader(in);

 

方法：

①int read();读取单个字符。

②int read(char[] cbuf,int offset,int length);将字符读入数组中的某一部分。

③void write(int c);写入单个字符。

④void write(char[] cbuf,int off,int len);写入字符数组的某一部分。

 

缓冲字符流：

BufferedReader BufferedWriter

BufferedReader br = new BufferedReader(ir);

 

方法：

①String readLine();读取一个文本行。

②int read(char[] cbuf,int off,int len);将字符读入数组的某一部分

③void newLine();写入一个行分隔符。

④void write(char[] cbuf,int off,int len);

 

属性文件：如 a.properties

文件内容的格式

键 = 值

A = abc(不用引号)

Properties pro = new Properties();

Pro.load(new FileInputStream(new File()));

 

线程：

①继承Thread类（重写run方法）调用start()方法启动

②实现Runnable接口（重写run方法）

RunTh rt = new RunTh();

Thread th = new Thread(rt);

Th.start();

 

主要方法：

①Thread.sleep(1000);停顿1秒

②th.join(long millis);等待该线程终止的时间最长为 millis 毫秒。

③获取当前线程的名字： Thread.currentThread().getName();

 

锁对象：java任何一个对象都可以作为锁使用。

 

①同步代码块

Synchronized(所对象){

//代码块

}

 

②同步方法（默认使用this锁）

访问修饰符 synchronized 返回值类型 方法名（参数）{

 

}