1-数组

数组初始化两种形式

int[] nums1 = new int[3];
int[] nums2 = {1,2,3};

可变参数的使用：返回值类型方法名称(类型... 参数名称)

    public static void main(String[] args) {System.out.println(fun());System.out.println(fun(1,2,3));System.out.println(fun(1,2,3,4,5));}public static int fun(int... nums){int num=0;for (int i = 0; i < nums.length; i++) {num+=nums[i];}return num;}

2-线程与进程

2.1-实现多线程：

1-继承Thread类

2-实现runnable接口

当启动多线程时，依靠Thread类来启动

public class TestUtil {public static void main(String[] args) {Thread thread1 = new Thread(new MyThread2("lx"));Thread thread2 = new Thread(new MyThread("txq"));thread1.start();thread2.start();}}//继承Thread类
public class MyThread extends Thread{private String name;public MyThread(String name) {this.name = name;}@Overridepublic void run() {System.out.println(name + " -> is running!");for (int i = 0; i < 10; i++) {System.out.println(name + "->" + i);}}
}//实现Runnable接口
public class MyThread2 implements Runnable{private String name;public MyThread2(String name) {this.name = name;}@Overridepublic void run() {System.out.println(name + " -> is running!");for (int i = 0; i < 10; i++) {System.out.println(name + "->" + i);}}
}

3-泛型

3.1-泛型上限

类名称<泛型标识 extend 类> {}

public class TestUtil {public static void main(String[] args) {Point point = new Point();String x = "11";double y = 20.222;point.setX(x);//Object上限不会报错 Number上限会报错point.setY(y);System.out.println(point.toString());}}
class Point<T extends Number>{private T x;private T y;public T getX() {return x;}public T getY() {return y;}public void setX(T x) {this.x = x;}public void setY(T y) {this.y = y;}@Overridepublic String toString() {return "Point{" +"x=" + x +", y=" + y +'}';}
}class Point<T extends Object>{private T x;private T y;public T getX() {return x;}public T getY() {return y;}public void setX(T x) {this.x = x;}public void setY(T y) {this.y = y;}@Overridepublic String toString() {return "Point{" +"x=" + x +", y=" + y +'}';}
}

4-Runtime类

getRuntime() 获取Runtime类的实例

freeMemory() 获取Java虚拟机空闲内存

maxMemory() 返回JVM最大内存

gc() 进行垃圾回收，释放空间

exec() 执行外部命令

public class TestUtil {public static void main(String[] args) {Runtime runtime = Runtime.getRuntime();System.out.println("最大内存："+runtime.maxMemory()/1024/1024 + "M");//最大内存System.out.println("空闲内存："+runtime.freeMemory()/1024/1024 + "M");//空闲内存String s = "txq"+"123"+"456";System.out.println(s);for (int i = 0; i < 1000; i++) {s += i;}System.out.println("产生垃圾后，空闲内存："+runtime.freeMemory()/1024/1024 + "M");runtime.gc();System.out.println("垃圾清除后，空闲内存："+runtime.freeMemory()/1024/1024 + "M");try{//QQ文件路径File file = new File("E:\\Program Files\\Tencent\\QQ\\Bin\\QQScLauncher.exe");//启动QQruntime.exec(file.getAbsolutePath());} catch (Exception e){System.out.println(e);}}
}

5-BeanUtils.copyProperties使用总结

5.1-BeanUtils.copyProperties有两个包：

//org.springframework.beans.BeanUtils
public static void copyProperties(Object source, Object target) throws BeansException//org.apache.commons.beanutils.BeanUtils
public static void copyProperties(final Object dest, final Object orig) throws IllegalAccessException, InvocationTargetException

区别：

A B为两个对象，需要将A对象【源对象】的值赋值给B【目标对象】

org.springframework.beans.BeanUtils的第一个参数为A，第二个参数为B
org.apache.commons.beanutils.BeanUtils的第一个参数为B，第二个参数为A

实验：

A为Student对象，B为Teacher对象

1-AB参数名称类型完全相同：均可正常运行切正常传递参数

2-A参数比B参数多：均可正常运行切正常传递参数

BeanUtils工具类中的copyProperties方法使用_野生开发者的博客-CSDN博客_copyproperties

此处与上述链接说法不一致，A目标对象（target/dest）中不包含B被copy的对象（source/orig）的所有字段时，上述链接中说org.apache.commons.beanutils.BeanUtils的copyProperties会报错，此处作者代码运行正常可正常赋值。

@Data
public class Student {private String name;private String age;private String sex;public Student(String name, String age, String sex) {this.name = name;this.age = age;this.sex = sex;}public Student() {}
}@Data
public class Teacher {private String name;private String age;//private String sex;//private String address;public Teacher() {}public Teacher(String name, String age) {this.name = name;this.age = age;}/*    public Teacher(String name, String age,String sex,String address) {this.name = name;this.age = age;this.sex = sex;this.address = address;}*/
}import beans.Student;
import beans.Teacher;
import org.apache.commons.beanutils.BeanUtils;import java.lang.reflect.InvocationTargetException;public class test {public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {Student txq = new Student("txq","25","1");Teacher lx = new Teacher();BeanUtils.copyProperties(lx,txq);System.out.println(lx.toString());}
}

运行结果：

3-A参数比B参数少：均可正常运行切正常传递参数

4-AB参数的名称相同但类型不同：

org.springframework.beans.BeanUtils中名称相同但类型不同的属性未能正常赋值，显示为null，其他名称类型完全的属性可正常赋值；

org.apache.commons.beanutils.BeanUtils中可正常赋值【正常进行类型转换，可转换则正常赋值，不可转换则赋初值，例如Interger类型会赋值0】

5.2-BeanUtils.copyProperties是深拷贝还是浅拷贝？

浅拷贝（shallowCopy）只是增加了一个指针指向已存在的内存地址；

深拷贝（deepCopy）是增加了一个指针并且申请了一个新的内存，使这个增加的指针指向这个新的内存，使用深拷贝的情况下，释放内存的时候不会因为出现浅拷贝时释放同一个内存的错误。

先说结论，两个包的copyProperties均为浅拷贝。

@Data
public class Student {private String name;private String age;private String sex;private Work work;public Student(String name, String age, String sex, Work work) {this.name = name;this.age = age;this.sex = sex;this.work = work;}public Student() {}
}@Data
public class Teacher {private String name;private Integer age;private String sex;private String address;private Work work;public Teacher() {}public Teacher(String name, Integer age) {this.name = name;this.age = age;}public Teacher(String name, Integer age,String sex,String address,Work work) {this.name = name;this.age = age;this.sex = sex;this.address = address;this.work = work;}
}@Data
public class Work {private String type;private Integer salary;public Work() {}public Work(String type, Integer salary) {this.type = type;this.salary = salary;}
}public class test {public static void main(String[] args) throws InvocationTargetException, IllegalAccessException {Student txq = new Student("txq","txq-1","1",new Work("c++",12000));Teacher lx = new Teacher();BeanUtils.copyProperties(lx,txq);System.out.println(txq.toString());System.out.println(lx.toString());lx.getWork().setType("php");System.out.println(txq.toString());System.out.println(lx.toString());}
}

运行结果如下：

当修改了Teacher中Work的Type属性时，正常Student中的Work属性值不应该发生变化，但是此时结果显示Student的结果也被修改，说明两者中的Work对象是同一个对象，所以为浅拷贝。

6-Comparable接口

comparable接口用于指定对象的排序规则，接口定义如下：

public interface Comparable<T>{public int compareTo(T o);
}

其中主要是实现compareTo接口，并返回一个int的值：

1：大于【大于0】

-1：小于【小于0】

0：等于【=0】

@Data
public class Student implements Comparable<Student>{private String name;private Integer age;private Integer score;public Student() {}public Student(String name, Integer age, Integer score) {this.name = name;this.age = age;this.score = score;}@Overridepublic int compareTo(Student student) {if (this.score>student.score){return 5;}else if (this.score<student.score){return -5;}else {if (this.age > student.age){return 5;}else {return -5;}}}
}public class test {public static void main(String[] args){Student[] students = {new Student("txq",25,80),new Student("txq",23,100),new Student("txq",24,90)};Arrays.sort(students);for (int i = 0; i < students.length; i++) {System.out.println(students[i]);}}
}运行结果：
Student(name=txq, age=25, score=80)
Student(name=txq, age=24, score=90)
Student(name=txq, age=23, score=100)

7-观察者模式

观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。

这个主题对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己。

1-定义观察者接口：为所有具体的观察者定义一个接口，在得到主题的通知时更新自己。

2-定义被观察者接口：把所有对观察者对象的引用保存在一个集合中，每个抽象主题角色都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

3-定义观察者实体类：该角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。通常用一个子类实现。如果需要，具体观察者角色可以保存一个指向具体主题角色的引用。

4-定义被观察者实体类：在具体主题内部状态改变时，给所有登记过的观察者发出通知。具体主题角色通常用一个子类实现。

//观察者接口
public interface Watcher {public void update(String str);
}//被观察者接口
public interface Watched {public void addWatcher(Watcher watcher);public void removedWatcher(Watcher watcher);public void notifyWatcher(String str);
}//房价观察者
@Data
public class HouseWatcher implements Watcher{private String name;public HouseWatcher(String name) {this.name = name;}@Overridepublic void update(String str) {System.out.println(name + "观察到" +str);}
}//房屋实体类-被观察者
@Data
public class House implements Watched{private float price;public void setPrice(float price) {this.price = price;this.notifyWatcher("房价调整至：" + price);}//定义观察者private List<Watcher> list = new ArrayList<>();@Overridepublic void addWatcher(Watcher watcher) {list.add(watcher);}@Overridepublic void removedWatcher(Watcher watcher) {list.remove(watcher);}@Overridepublic void notifyWatcher(String str) {for (Watcher w: list) {w.update(str);}}
}public class test {public static void main(String[] args){Watched house = new House();Watcher watcher1 = new HouseWatcher("滕新桥");Watcher watcher2 = new HouseWatcher("lx");Watcher watcher3 = new HouseWatcher("llw");house.addWatcher(watcher1);house.addWatcher(watcher2);house.addWatcher(watcher3);((House) house).setPrice(5000);}
}运行结果：
滕新桥观察到房价调整至：5000.0
lx观察到房价调整至：5000.0
llw观察到房价调整至：5000.0

Java开发实战经典【Java基础】相关推荐

李兴华java视频在线观看_李兴华Java开发实战经典视频教程_IT教程网
资源名称:李兴华Java开发实战经典视频教程资源目录: [IT教程网]010201_[第2章:简单Java程序]_简单Java程序 [IT教程网]010301_[第3章:Java基础程序设计]_Ja ...
李兴华java实战经典视频_李兴华Java开发实战经典视频教程
资源名称:李兴华Java开发实战经典视频教程资源目录:[一品资源网]010201_[第2章:简单Java程序]_简单Java程序[一品资源网]010301_[第3章:Java基础程序设计]_Java ...
Java开发实战经典目录
目录第1部分 Java基础程序设计第1章 Java概述及开发环境搭建 2 视频讲解:35分钟 1.1 认识Java 2 1.1.1 什么是Java 2 1.1.2 Java语言的特点 3 ...
吃一堑长一智！java开发实战经典答案百度云
第一个:Alibaba[搜索推荐] 一面:算法题:长度为n的数组里放了n+1个大小在[1,n]的数,必然至少有一个重复的数,找出来二面:概率题:求一根绳子被切两刀能组成一个三角形的概率. 三面主管面 ...
2021年Java开发实战！java培训视频网站
K8S:深入浅出Kubernetes(理论+实战) Kubernetes(k8s)是一个全新的基于容器技术的分布式架构领先方案.Kubernetes(k8s)是Google开源的容器集群管理系统(谷歌 ...
Java开发实战！java环境搭建是什么意思
前言设计模式是我们编程道路上绕不开的一环,用好了设计模式能够让代码拥有良好的维护性.可读性以及扩展性,它仿佛就是"优雅"的代名词,各个框架和库也都能见到它的身影. 正是因为它有种 ...
GitHub上标星75k+超牛的《Java面试突击版》，java开发实战经典第二版答案
运筹帷幄之后,决胜千里之外!不打毫无准备的仗,我觉得大家可以先从下面几个方面来准备面试: 1.自我介绍.(你可千万这样介绍: "我叫某某,性别,来自哪里,学校是哪个,自己爱干什么" ...
Java开发实战经典第二版，小白也能看明白
数据库 2.1 池化技术:如何减少频繁创建数据库连接的性能损耗? 2.2 数据库优化方案(一):查询请求增加时,如何做主从分离? 2.3 数据库优化方案(二):写入数据量增加时,如何实现分库分表? 2 ...
【Java笔记】Java开发实战经典 - 第五章
===第五章面向对象(基础篇) 面向对象的程序设计有封装性.继承性.多态性3个主要特征: 类是抽象的代表共性,对象是具体的个体,属性是描述对象的信息,方法是对象的行为: 类由属性和方法组成,属性就是 ...
java开发实战经典答案百度云，含面试题+答案
1.上下文切换上下文定义 cpu发生进程或者线程切换时,所依赖的数据集合,比如一个函数有外部变量,函数运行时,必须获取外部变量,这些变量值的集合就是上下文. 引发问题对于CPU密集型任务,多线程处 ...

Java开发实战经典【Java基础】