整理些JAVA基础（二）

最新推荐文章于 2024-05-05 13:57:09 发布

weixin_47352169

最新推荐文章于 2024-05-05 13:57:09 发布

阅读量118

点赞数

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_47352169/article/details/107850619

版权

java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

final关键字：
1、修饰类，类不能被继承
2、修饰变量，变量就变成了常量，且只能被赋值一次
3、修饰方法，方法不能被重写

static关键字（单例模式…）
1、静态方法可以使用对象名去调用，也可以使用类名去调用。（建议使用类名去调用）
2、在静态方法只能访问静态的成员变量和静态的成员方法
3、在非静态方法中，可以调用静态方法
4、在静态方法中，不能使用关键字：this、super
原因：静态内容是随着类的加载而加载，而this和super是随着对象的创建而存在
对底层的JVM来讲，不存在使用对象名的方式调用，当使用对象名调用静态方法时，JVM会根据对象所属的类型(类)，通过”类名.静态方法()”的方式去调用静态方法

抽象类:
问题1：抽象类一定必须是父类吗？
肯定是。因为抽象类是通过不断的向上抽取而形成

问题2：抽象类中有构造方法吗？
有构造方法。抽象类中的构造方法仅仅是为了子类对象实例化时使用的

问题3：抽象类中的可以书写非抽象内容吗？（除了抽象方法可以有其它成员吗？）
可以。抽象类比普通类只多了抽象方法。抽象类仅仅是希望父类不能实例化

问题4：关键字abstract不能和哪些关键字共存？（不能一起使用）
private关键字：表示私有化。
当父类中的抽象方法修饰为private后，表示该方法只属于父类，子类无法继承，子类不能继承，就不存在方法重写（抽象方法必须重写）

final关键字：表示最终的、不可改变的
当抽象类修饰为final后，表示该抽象类不能被继承（抽象类必须被继承）
当抽象方法修饰为final后，表示该抽象方法不能被重写（抽象方法必须被子类重写）

static关键字：表示静态的。静态的内容是可以通过类名来访问
当抽象方法修饰为static后，表示该抽象方法可以通过类名访问，但是如果使用类名去调用抽象方法，是没有任何意义的（抽象方法中没有任何代码实现）

interface 接口:（工厂模式，代理模式应用）
成员变量
只能是常量
默认修饰符 public static final
构造方法
没有，因为接口主要是扩展功能的，而没有具体存在
成员方法
只能是抽象方法
默认修饰符 public abstract
例：

interface Function1{}
interface Function2{}
class Dog extends Animal implements Function1,Function2{}

权限级别：
在这里插入图片描述

String类的特点：
String类不能被继承。原因：public final class String
String类中存储的都是字符串常量对象，而字符串常量对象所引用的常量值是存放在方法区下的常量池中
String类中存储的字符串常量，在初始化后，就不能修改其值了。一旦修改就相当于重新创建了一个字符串常量对象
遍历字符串：

for(int x=0; x<s.length(); x++) {
			System.out.println(s.charAt(x));
		}

StringBuilder
字符串缓冲区类。定义一个类，类中有一个可变数组
常用方法：
append(任何类型的数据) 追加数据
toString() 把StringBuilder字符串，转为String字符串
new StringBuilder() 初始大小16个字符

基本类型： byte 、short 、int 、long 、boolean 、float 、double 、char
包装类： Byte 、Short 、Integer 、Long 、Boolean 、Float 、Double 、Character
作用：基本类型数据通常只有两个功能：赋值、取值
当把基本类型封装为类后，就可以使用更多的功能来操作基本类型数据
例：

int	--	Stringi
  	String类中：public static String valueOf(int i)
  
String	--	int
  	Integer类中：public static int parseInt(String s)
日期的：
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		Date d = sdf.parse(new Date());

集合：
Collection接口：单列数据，定义了存取一组对象的方法的集合
List：元素有序、可重复的集合
Set：元素无序、不可重复的集合
Map接口：双列数据，保存具有映射关系“key-value对”的集合

遍历： 建议 增强for
注意不能为null;
或者用迭代器：
Collection<Integer> list1 = new ArrayList<>();
		list1.add(1);
		list1.add(2);
		list1.add(3);
		Iterator it = list1.iterator();
		while(it.hasNext()){
			Integer next = (Integer) it.next();
			System.out.println(next);
		}

Collection集合下，存在两个子集合对象：List、Set
常用方法：
min、max(Collection):根据元素自然顺序返回最大\小元素；
min、max(Collection,comparator):根据comparator指定的顺序，返回最大\小值；
int frequency(Collection,object):返回集合中指定元素出现的次数；
shuffle(List)：对List集合元素进行随机排序；
swap(List,int i,int j):将List集合中的i处元素和j处元素互换

List下：
ArrayList特点：查询效率快，增删慢
(JDK1.7：ArrayList像饿汉式，直接创建一个初始容量为10的数组
JDK1.8：ArrayList像懒汉式，一开始创建一个长度为0的数组，当添加第一个元素时再创建一个始容量为10的数组)

LinkedList集合的特点：查询效率低，增删效率高
(LinkedList：双向链表，内部没有声明数组，而是定义了Node类型的first和last，用于记录首末元素。同时，定义内部类Node，作为LinkedList中保存数据的基本结构。Node除了保存数据，还定义了两个变量：
prev变量记录前一个元素的位置
next变量记录下一个元素的位置)

Vector特点：线程安全的，但效率低
Set下：
HashSet(主要实现类,底层也是数组，初始容量为16，当如果使用率超过0.75，（16*0.75=12）就会扩大容量为原来的2倍。)
TreeSet(可以确保集合元素处于排序状态，底层红黑树结构存储，自然排序和定制排序)
LinkedHashSet（使用链表维护添加进set的顺序，所以遍历set的时候是按添加的顺序遍历，这使得元素看起来是以插入顺序保存的）

不允许存储重复元素、最多只能存储一个null元素，没有角标
List集合的特点：
1、有序（存储和取出元素的顺序一致）
2、对集合中的每个元素的插入进行精确地控制（可以指定元素插入在集合的哪个位置上）
3、具有角标，可以利用角标去访问集合中的元素
4、允许有重复的元素
List集合的特有方法：
添加元素方法：void add(int index,Object obj)
向List集合中指定的index角标位置上添加obj元素。（注：如index角标位置上存在元素，则会把已经存在的元素向后移动，新元素添加到当前角标位置上）
删除元素方法：Object remove(int index)
从List集合中删除指定index角标位置上的元素，并返回被删除的元素
修改元素方法：Object set(int index,Object obj)
修改List集合中指定的index角标位置上元素，修改为obj元素。并返回旧的元素
获取元素方法：Object get(int index)
获取集合中指定index角标位置上的元素

Map集合的特点：
HashMap(主要实现类，允许使用null键和null值)
LinkedHashMap(使用链表维护添加进map的顺序，所以遍历map的时候是按添加的顺序遍历)
TreeMap(按照添加进map的key的指定属性排序，底层使用红黑树结构)
Hashtable（线程安全，有常用子类properties()，不允许使用 null 作为 key 和 value）

1、Map集合中一次可以存储两个对象：键(key)、值(value)对象
2、Map集合在存储键时，不允许有重复的键对象元素（键唯一性）
3、Map集合中的键只能对应一个值（键和值是一一对应）

V get(Object key):根据键获取值
Set<K> keySet(): 获取所有键的集合
Collection<V> values():获取所有值的集合

异常处理：
捕获（try…catch）、声明（throws）
try…catch：在方法执行过程中，如发生了异常，则方法自己内部处理异常
throws：在方法执行过程中，如发生了异常，则方法本身不处理异常，把异常抛给调用者，让调用者去处理异常（处理方案：try/catch）

File类：
路径分隔符和系统有关：
windows和DOS系统默认使用“\”来表示
UNIX和URL使用“/”来表示
public static final String separator。根据操作系统，动态的提供分隔符

File file2 = new File("d:" + File.separator + "test" + File.separator + "xx.txt");

Java语言使用File封装类来描述硬盘中的文件或者目录
绝对路径：带有根目录(盘符)的文件路径名 c:\temp\demo.java
相对路径：不带根目录(盘符)文件路径名 temp\demo.java
public String getAbsolutePath() 获取绝对路径
public String getPath() 获取路径(用什么方式创建的对象,就返回什么方式的路径(绝对路径/相对路径))
public String getName() 获取文件/文件夹的名称
public String getParent() 返回所在文件夹路径
public boolean delete() 删除文件
public boolean createNewFile() throws IOException 创建文件。
说明：在创建文件时，如果文件所在的文件夹不存在则报错。(创建文件时必须确保文件路径已存在)
public boolean mkdir() 创建文件夹。
说明：使用mkdir方法创建文件夹时,必须保证其所在文件夹已经存在,否则创建失败(不会报错)
public boolean mkdirs() 一次性创建多级目录
public boolean delete() 删除文件夹不能为空,否则删除失败
public boolean exists() 文件或者文件夹是否存在
public boolean isDirectory() 判断文件对象是否为文件夹
public boolean isFile() 判断文件对象是否为文件
createNewFile()，mkdir() 适合绝对路径，相对路径试了几次，好像都不行。

File file = new File("D:\...\\src\\main\\resources\\static\\Test2");
        boolean mkdir = file.mkdir();
        System.out.println(mkdir);
        boolean newFile = new File(file, "ww.txt").createNewFile();
        System.out.println(newFile);

IO流：

FileOutputStream outputStream = new FileOutputStream("D:\\...src\\main\\resources\\static\\ww.txt");
		outputStream.write("kkkkkkk".getBytes());
		outputStream.close();
		//下面的写入文件末尾
		FileOutputStream outputStream2 = new FileOutputStream("D:\\...src\\main\\resources\\static\\ww.txt", true);
		outputStream2.write("xxxxxxx".getBytes());
		outputStream2.close();
		FileInputStream fileInputStream = new FileInputStream("D:\\...\\src\\main\\resources\\static\\ww.txt");
		byte[] bytes = new byte[1024];
		//定义变量,用于记录每次读取到的字节长度
		int len;
		//循环读取,直到文件末尾
		while( (len=fileInputStream.read(bytes)) != -1) {
			//将字节数组变成字符串,方便观察(通过字符串的构造方法)
			//本次读取到几个字节,就转换成几个字节为字符串
			String s = new String(bytes,0,len);
			//可以直接写入新文件
			//例 outputStream.write(bytes,0,len)
			System.out.println(s);
		}
		fileInputStream.close();

FileReader reader = new FileReader("D:\\...\\src\\main\\resources\\static\\ww.txt");
		FileWriter writer = new FileWriter("D:\\...\\src\\main\\resources\\static\\ww.txt",true);
		char arr[] = new char [1024];
		while (reader.read(arr)!=-1){
			writer.write(arr);
		}
		writer.write("hello kkk");
		reader.close();
		writer.close();

new InputStreamReader(new FileInputStream(), “UTF-8”);
new OutputStream(new FileOutputStream(), “UTF-8”);
他们和字符流不同的地方，他们可以指定编码表

缓冲流：（工作中常用，提高数据读写的速度）
BufferedInputStream
BufferedOutputStream
BufferedReader
BufferedWriter

BufferedReader br = null;
BufferedWriter bw = null;
try {
// 创建缓冲流对象：它是处理流，是对节点流的包装
br = new BufferedReader(new FileReader(new File("d:\\...\\kkk.txt")));
bw = new BufferedWriter(new FileWriter(new File("d:\\...\\xxx.txt"));
String str;
while ((str = br.readLine()) != null) { // 一次读取字符文本文件的一行字符
bw.write(str); // 一次写入一行字符串
bw.newLine(); // 写入行分隔符
}
bw.flush(); // 刷新缓冲区
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭IO流对象
try {
if (bw != null) {
bw.close(); // 关闭过滤流时,会自动关闭它所包装的底层节点流
}
} catch (IOException e) {
e.printStackTrace();
}
try {
if (br != null) {
br.close();
}
} catch (IOException e) {
e.printStackTrace();
} }

转换流：
例 UTF-8转GBK：

FileInputStream fis = new FileInputStream(new File("d:\\...\\kkk.txt"));
FileOutputStream fos = new FileOutputStream(new File("d:\\...\\xxx.txt"));
InputStreamReader isr = new InputStreamReader(fis, "GBK");
OutputStreamWriter osw = new OutputStreamWriter(fos, "GBK");
BufferedReader br = new BufferedReader(isr);
BufferedWriter bw = new BufferedWriter(osw);
String str = null;
while ((str = br.readLine()) != null) {
bw.write(str);
bw.newLine();
bw.flush();
}
bw.close();
br.close();

关于枚举类：
使用 enum 定义的枚举类默认继承了 java.lang.Enum类，因此不能再继承其他类
枚举类的构造器只能使用 private 权限修饰符
枚举类的所有实例必须在枚举类中显式列出(, 分隔 ; 结尾)。列出的实例系统会自动添加 public static final 修饰
必须在枚举类的第一行声明枚举类对象

public enum SeasonEnum {
SPRING("春天","春...."),
SUMMER("夏天","夏...."),
AUTUMN("秋天","秋...."),
WINTER("冬天","冬....");
private final String seasonName;
private final String seasonDesc;

private SeasonEnum(String seasonName, String seasonDesc) {
this.seasonName = seasonName;
this.seasonDesc = seasonDesc; 
}
public String getSeasonName() {
return seasonName; 
}
public String getSeasonDesc() {
return seasonDesc; 
} 

}

values()方法：返回枚举类型的对象数组。该方法可以很方便地遍历所有的枚举值。
valueOf(String str)：可以把一个字符串转为对应的枚举类对象。要求字符串必须是枚举类对象的“名字”。如不是，会有运行时异常：IllegalArgumentException。
toString()：返回当前枚举类对象常量的名称。

注解：
元注解：
@Retention:
只能用于修饰一个 Annotation 定义, 用于指定该 Annotation 的生命周期, @Rentention 包含一个 RetentionPolicy 类型的成员变量, 使用@Rentention 时必须为该 value 成员变量指定:

RetentionPolicy.SOURCE:在源文件中有效（即源文件保留），编译器直接丢弃这种策略的注释

RetentionPolicy.CLASS:在class文件中有效（即class保留），当运行 Java 程序时, JVM 不会保留注解。这是默认值

RetentionPolicy.RUNTIME:在运行时有效（即运行时保留），当运行 Java 程序时, JVM 会保留注释。程序可以通过反射获取该注释。

@Target:
用于修饰 Annotation 定义, 用于指定被修饰的 Annotation 能用于修饰哪些程序元素。 @Target 也包含一个名为 value 的成员变量。

@Documented:
用于指定被该元 Annotation 修饰的 Annotation 类将被javadoc 工具提取成文档。默认情况下，javadoc是不包括注解的。定义为Documented的注解必须设置Retention值为RUNTIME。

@Inherited:
被它修饰的 Annotation 将具有继承性。如果某个类使用了被@Inherited 修饰的 Annotation, 则其子类将自动具有该注解。

JDK1.8之后，关于元注解@Target的参数类型ElementType枚举值多了两个：TYPE_PARAMETER,TYPE_USE。
在Java 8之前，注解只能是在声明的地方所使用，Java8开始，注解可以应用在任何地方。
ElementType.TYPE_PARAMETER 表示该注解能写在类型变量的声明语句中（如：泛型声明）。
ElementType.TYPE_USE 表示该注解能写在使用类型的任何语句中。

public class TestTypeDefine<@TypeDefine() U> {
private U u;
public <@TypeDefine() T> void test(T t){
} }
@Target({ElementType.TYPE_PARAMETER})
@interface TypeDefine{ }

weixin_47352169

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
整理些JAVA基础（二）

final关键字：1、修饰类，类不能被继承2、修饰变量，变量就变成了常量，且只能被赋值一次3、修饰方法，方法不能被重写static关键字:1、静态方法可以使用对象名去调用，也可以使用类名去调用。（建议使用类名去调用）2、在静态方法只能访问静态的成员变量和静态的成员方法3、在非静态方法中，可以调用静态方法4、在静态方法中，不能使用关键字：this、super原因：静态内容是随着类的加载而加载，而this和super是随着对象的创建而存在对底层的JVM来讲，不存在使用对象名的方式调用，当使
复制链接

扫一扫