java小知识点总结

最新推荐文章于 2024-07-09 23:29:46 发布

2015_Sky_Baby_Go

最新推荐文章于 2024-07-09 23:29:46 发布

阅读量1.6k

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/wangbadan007007/article/details/12908537

版权

Java 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流！ --------------

假克隆：

   对于基本类型可以使用 = 来进行克隆，此时两个变量除了相等没有任何关系，

   但对于引用类型却不能简单的使用 = 进行克隆，这主要是于 java的内存空间使用有关。

   通常情况很少使用 = 来操作对象，也很少使用 == 来比较两个对象。

   定义一个Employee类：如下

package com.mingrisoft.oop;
public class Employee {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "姓名：" + name + ", 年龄：" + age;
}
}

复制代码

以下是main函数：

package com.mingrisoft.oop;
public class Test {
public static void main(String[] args) {
System.out.println("克隆之前：");
Employee employee1 = new Employee();
employee1.setName("java1");
employee1.setAge(12);
System.out.println("员工1的信息：");
System.out.println(employee1);
System.out.println("克隆之后：");
Employee employee2 = employee1;
employee2.setName("web1");
employee2.setAge(34);
System.out.println("员工2的信息：");
System.out.println(employee2);
System.out.println("员工1的信息：");
System.out.println(employee1);
}
}

复制代码

打印信息如下：

克隆之前：
员工1的信息：
姓名：java1, 年龄：12
克隆之后：
员工2的信息：
姓名：web1, 年龄：34
员工1的信息：
姓名：web1, 年龄：34

复制代码

当修改Employee2 的时候 employmee1 的内容也被修改了。并没有达到克隆目的。

浅克隆如下：

package com.mingrisoft.oop;
public class Employee implements Cloneable {
private String name;
private int age;
private Address address; //此变量是一个自定义里变量。
public Employee(String name, int age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("姓名：" + name + ", ");
sb.append("年龄：" + age + "\n");
sb.append("地址：" + address);
return sb.toString();
}
@Override
public Employee clone() {
Employee employee = null;
try {
employee = (Employee) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return employee;
}
}

复制代码

main函数如下：

package com.mingrisoft.oop;
public class Test {
public static void main(String[] args) {
System.out.println("克隆之前：");
Address address = new Address("河北", "邯郸", "丛台");
Employee employee1 = new Employee("占二", 12, address);
System.out.println("员工1的信息：");
System.out.println(employee1);
System.out.println("克隆之后：");
Employee employee2 = employee1.clone();
employee2.getAddress().setState("中国");
employee2.getAddress().setProvince("云南");
employee2.getAddress().setCity("昆明");
employee2.setName("国美");
employee2.setAge(114);
System.out.println("员工2的信息：");
System.out.println(employee2);
System.out.println("员工1的信息：");
System.out.println(employee1);
}
}

复制代码

打印信息如下：

克隆之前：
员工1的信息：
姓名：占二, 年龄：12
地址：国家：河北, 省：邯郸, 市：丛台
克隆之后：
员工2的信息：
姓名：国美, 年龄：114
地址：国家：中国, 省：云南, 市：昆明
员工1的信息：
姓名：占二, 年龄：12
地址：国家：中国, 省：云南, 市：昆明

复制代码

分析可见：占二的姓名和年龄不没有被修改，但是地址信息被更改了。因为 String int 都可以实现值拷贝

有于自定义Address 类没有实现 Cloneable 接口所以，不能实现克隆，而是指向了同一个对象。

深克隆如下：

package com.mingrisoft.oop;
public class Address implements Cloneable {
private String state;
private String province;
private String city;
public Address(String state, String province, String city) {
this.state = state;
this.province = province;
this.city = city;
}
public String getState() {
return state;
}
public void setState(String state) {
this.state = state;
}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("国家：" + state + ", ");
sb.append("省：" + province + ", ");
sb.append("市：" + city);
return sb.toString();
}
@Override
protected Address clone() {
Address address = null;
try {
address = (Address) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return address;
}
}

复制代码

package com.mingrisoft.oop;
public class Employee implements Cloneable {
private String name;
private int age;
private Address address;
public Employee(String name, int age, Address address) {
this.name = name;
this.age = age;
this.address = address;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
sb.append("姓名：" + name + ", ");
sb.append("年龄：" + age + "\n");
sb.append("地址：" + address);
return sb.toString();
}
@Override
public Employee clone() {
Employee employee = null;
try {
employee = (Employee) super.clone();
employee.address = address.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return employee;
}
}

复制代码

打印信息如下：
克隆之前：
员工1的信息：
姓名：占二, 年龄：12
地址：国家：河北, 省：邯郸, 市：丛台
克隆之后：

员工2的信息：
姓名：国美, 年龄：114
地址：国家：中国, 省：云南, 市：昆明

员工1的信息：
姓名：占二, 年龄：12
地址：国家：河北, 省：邯郸, 市：丛台

占二的信息并没有被更改，从而实现了深克隆。

1：关于控制符的使用：

      * 类的绝大部分Field 都应该使用private修饰，只有一些static 修饰的，类似全局变量的Field才考虑
            使用public 修饰，所以不要动不动就整 public，此外，有些方法只是用于辅助该类的其他方法，这些方法
            被称为工具方法，工具方法也应该用private 修饰。

   *    如果某个类主要用作其他类的父类，该类里包含的大部分方法可能仅希望被其子类重写，而不想被外界
            直接调用，则应该使用protected 来修饰。

   * 希望暴露出来给其他类自由调用的方法应该使用public来修饰，因此类的构造器通过使用public 修饰，从而允许在其他
         的地方创建该类的实例。

2:    java 的常用包：

   *  java.lang 这个包下包含了java的核心类，如String  Math  System  和 Thread 类等，使用这个包无需使用import 语句导入，
                        系统会自动导入
   *  java.util 这个包下包含java的大量的工具类、接口和集合框架类、接口，例如Arrays  List  Set

   *  java.net 这个包是java网络编程相关的类和接口。

   *  java.io 这个包是输入和输出相关的类和接口。

   * java.text 这个包包含了了一些java 格式化相关的类。

   * java.sql 这个包包含了java 进行JDBC 数据库编程的相关类和接口。

   * java.awt 抽象窗口工具集，主要用于构建GUI界面。

   * java.swing  包含了Swing 图形用户界面编程的相关类和接口。这些类是轻量级的，用于构建和平台无关的GUI程序。

3：  子类和父类 :

      如果在子类中定义了与父类已有变量同名的变量，那么子类中定义的变量会隐藏父类中定义的变量。注意不是完全覆盖，

      因此系统在创建子类对象时，依然会为父类中定义的、被隐藏的变量分配内存空间。

      所以：为了在子类中能够访问到父类中定义的、被隐藏的实例变量。或者为了在子类中访问父类中定义的、被隐藏的方法，
                  可用通过super.  在达到访问的目的。

4：子类构造器调用父类构造器的集中情况：

      * 子类构造器执行体的第一行使用super 显示调用父类的构造器，系统将根据super 传入的实参列表调用父类对应的构造器。

      * 子类构造器执行体的第一行使用this 显示调用本类中的重载构造器，系统根据this 调用里传入的实参调用本类中的另一个构造
            器，而在这个构造器中会调用父类的构造器。

      * 子类构造器执行体中既没有super 调用，也没有this 调用，系统将会在执行子类构造器之前，隐士调用父类无参的构造器。

5： instanceof

         instanceof  和  （type ）  是java 提供的两个相关的运算符，通常先用instanceof 判断一个对象是否可以强制类型转换，

         然后才使用（type）进行强制类型转换，从而保证程序不会出现错误。

6：设计父类应该遵守如下规则：

      * 尽量隐藏父类的内部数据，不要让子类直接访问父类的field

      * 不要让子类可以随意访问修改父类的方法。

      * 尽量不要在父类构造器中调用将要被子类重写的方法。否则可能引起空指针异常。

7：抽象类和抽象方法：

      * 抽象类必须使用abstract 来修饰，抽象方法也必须使用abstract来修饰，抽象方法不能有方法体。

      *  抽象类不能被实例化。

      *  抽象类可以包含 Field  方法  构造器  初始化块  内部类枚举类  6部分，抽象类的构造器不能用于创建实例，主要用于被其子类调用。

      *  含有抽象方法的类只能被定义为抽象类。

8：  abstract 关键字使用注意点：

      * final 修饰的类不能被继承，final 修饰的方法不能被重写，所以 final  和abstract 永远不能被同时使用。

      * 当使用static 修饰一个方法时，表明这个方法属于这个类本身，如果将该方法定义为抽象方法，则将导致通过该类
         调用该方法是出现错误（调用一个没有方法体的方法肯定会出错）
         因此 static  和abstract  不能同时修饰某一个方法，即没有所谓的类抽象方法。

9：接口注意：

      *  对于接口定义的方法，他们只能是抽象方法，因此系统会自动为其增加abstract 修饰符，
         由于接口里的方法全部是抽象方法，因此接口里不允许定义静态方法，即不可以使用
         static 修饰接口里定义的方法。

      * 不管接口里方法是否用public abstract 来修饰，默认都采用public abstract 来修饰。

死锁与死锁解决

以下是一个会产生死锁的例子：

package com.mingrisoft.thread;
public class DeadLock implements Runnable {
private boolean flag;// 使用flag变量作为进入不同块的标志
private static final Object o1 = new Object();
private static final Object o2 = new Object();
public void run() {
String threadName = Thread.currentThread().getName();// 获得当前线程的名字
System.out.println(threadName + ": flag = " + flag);// 输出当前线程的flag变量值
if (flag == true) {
synchronized (o1) {// 为o1加锁
try {
Thread.sleep(1000);// 线程休眠1秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName + "进入同步块o1准备进入o2");// 显示进入o1块
synchronized (o2) {// 为o2加锁
System.out.println(threadName + "已经进入同步块o2");// 显示进入o2块
}
}
}
if (flag == false) {
synchronized (o2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName + "进入同步块o2准备进入o1");// 显示进入o2块
synchronized (o1) {
System.out.println(threadName + "已经进入同步块o1");// 显示进入o1块
}
}
}
}
public static void main(String[] args) {
DeadLock d1 = new DeadLock();// 创建DeadLock对象d1
DeadLock d2 = new DeadLock();// 创建DeadLock对象d2
d1.flag = true; // 将d1的flag设置为true
d2.flag = false; // 将d2的flag设置为false
new Thread(d1).start();// 在新线程中运行d1的run()方法
new Thread(d2).start();// 在新线程中运行d2的run()方法
}
}

复制代码

Thread(d1)和  Thread(d2)启动后会分别进入不同的if 分支
此时Thread(d1) 占有锁01   Thread(d2) 占有锁o2
sleep后 Thread(d1) 会去请求资源o2 而 Thread(d2)会去请求资源o1
这样你不给我不让  就造成了死锁。

死锁的条件如下:
  1: 资源互斥（资源只能供一个线程使用）
  2：  请求保持（拥有资源的线程在请求新的资源又不释放占有的资源）
  3：  不能掠夺（已经获得的资源在使用完成前不能掠夺）
  4：  循环等待（各个线程对资源的需求构成一个循环）

以上例子的解决办法：

public void run() {
String threadName = Thread.currentThread().getName();// 获得当前线程的名字
System.out.println(threadName + ": flag = " + flag);// 输出当前线程的flag变量值
if (flag == true) {
synchronized (o1) {// 为o1加锁
try {
Thread.sleep(1000);// 线程休眠1秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName + "进入同步块o1准备进入o2");// 显示进入o1块
System.out.println(threadName + "已经进入同步块o2");// 显示进入o2块***********注意少了synchronized (o2)
}
if (flag == false) {
synchronized (o2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(threadName + "进入同步块o2准备进入o1");// 显示进入o2块
synchronized (o1) {
System.out.println(threadName + "已经进入同步块o1");// 显示进入o1块
}
}
}
}

复制代码

解决办法 : 对于这四个同步块，去掉任何一个就可以解决死锁的问题。

死锁的输出如下：Thread-0: flag = true
Thread-1: flag = false
Thread-1进入同步块o2准备进入o1
Thread-0进入同步块o1准备进入o2

常见的异常类型

1：算数异常 ArithmeticException
除0 导致的异常

package com.mingrisoft.exceptions;
public class ExceptionTest {
public static void main(String[] args) {
System.out.println("-1.0 / 0 = " + (-1.0 / 0));// 演示负浮点数除0
System.out.println("+1.0 / 0 = " + (+1.0 / 0));// 演示正浮点数除0
System.out.println("-1 / 0 = " + (-1 / 0));// 演示负整数除0
System.out.println("+1 / 0 = " + (-1 / 0));// 演示正整数除0
}
}

复制代码

错误：Exception in thread "main" java.lang.ArithmeticException: / by zero

2：数组存值异常 ArrayStoreException

在String 数组中存入了 Integer 对象

package com.mingrisoft.exceptions;
public class ExceptionTest {
public static void main(String[] args) {
Object array[] = new String[3]; // 声明一个长度为3的Object类型的数组
array[0] = new Integer(1); // 将数组的第一个元素赋值为整数对象1
System.out.println(array[0]); // 输出数组的第一个元素
}
}

复制代码

错误： Exception in thread "main" java.lang.ArrayStoreException: java.lang.Integer

3：数组下标越界异常 ArrayIndexOutOfBoundsException

数组length为 5，遍历的时候到了 5

package com.mingrisoft.exceptions;
import java.util.Arrays;
public class ExceptionTest {
public static void main(String[] args) {
int[] array = new int[5]; // 声明一个长度为5的整型数组
Arrays.fill(array, 8); // 将新声明的数组所有元素赋值为8
for (int i = 0; i < 6; i++) {// 遍历输出所有数组元素
System.out.println("array[" + i + "] = " + array[i]);
}
}
}

复制代码

错误： Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5

4:  空指针异常  NullPointerException
         string 对象为 null
         调用它的函数会导致空指针异常。

package com.mingrisoft.exceptions;
public class ExceptionTest {
@SuppressWarnings("null")
public static void main(String[] args) {
String string = null;// 将字符串设置为null
System.out.println(string.toLowerCase());// 将字符串转换成小写
}
}

复制代码

错误： Exception in thread "main" java.lang.NullPointerException

5：类未发现异常 ClassNotFoundException

由于我本机并没有 com.mysql.jdbc.Driver

package com.mingrisoft.exceptions;
public class ExceptionTest {
public static void main(String[] args) {
try {
Class.forName("com.mysql.jdbc.Driver");// 加载MySQL驱动程序
} catch (ClassNotFoundException e) {// 捕获异常
e.printStackTrace();// 打印堆栈信息
}
}
}

复制代码

错误： java.lang.ClassNotFoundException: com.mysql.jdbc.Driver

6：非法访问异常    IllegalAccessException
      这个例子是涉及到反射技术。

      试图要访问String  这个类中的hash 成员变量。 hash 变量为private

package com.mingrisoft.exceptions;
import java.lang.reflect.Field;
public class ExceptionTest {
public static void main(String[] args) {
Class<?> clazz = String.class;// 获得代表String类的类对象
Field[] fields = clazz.getDeclaredFields();// 获得String类的所有域
for (Field field : fields) {// 遍历所有域
if (field.getName().equals("hash")) {// 如果域的名字是hash
try {
System.out.println(field.getInt("hash"));// 输出hash的值
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}
}

复制代码

错误： java.lang.IllegalAccessException: Class com.mingrisoft.exceptions.ExceptionTest can not access a member of class java.lang.String with modifiers "private"

7：文件未发现异常： FileNotFoundException

我的机子并没有这个文件 d:\\kira.txt"

package com.mingrisoft.exceptions;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class ExceptionTest {
public static void main(String[] args) {
FileInputStream fis = null;// 创建一个文件输入流对象
try {
File file = new File("d:\\kira.txt");// 创建一个文件对象
fis = new FileInputStream(file);// 初始化文件输入流对象
} catch (FileNotFoundException e) {// 捕获异常
e.printStackTrace();
} finally {
try {
fis.close();// 释放资源
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

复制代码

错误： java.io.FileNotFoundException: d:\kira.txt (系统找不到指定的文件。)

------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流！ -------------

详情请查看：http://edu.csdn.net/heima/

2015_Sky_Baby_Go

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java小知识点总结

------------- java培训、android培训、java博客、java学习型技术博客、期待与您交流！ -------------- 假克隆：对于基本类型可以使用 = 来进行克隆，此时两个变量除了相等没有任何关系，但对于引用类型却不能简单的使用 = 进行克隆，这主要是于 java的内存空间使用有关。
复制链接

扫一扫

专栏目录