一、基础知识，通过代码进行解释
package helloJava;//package 包的关键字，相当于整个代码的目录
public class helloMain {
static String strr = "nihao";//全局变量//必须得用static定义，否则程序会出错
private static String str = "是我学习Java语言的最佳书籍";
public static void main(String[] args) {//必须有该句，才能运行程序，且格式是固定的
int s = 0;
String str = "";//局部变量
System.out.print("《Java入门到精通》！" + "\r\n" + str + strr);
}
}java中main()方法为主方法，是程序开始执行的地方，必须按照如下的方式进行定义
public static void main(String[] args)
//单行注释
/**/ 多行注释，但在多行注释中，不能嵌套多行注释
/** */ 为文档注释
二、数据基本类型
三、变量与常量
1. 常量：final
final 数据类型 常量名称 = 值
final double PI = 3.1415926
2. 成员变量
成员变量又分为 实例变量和静态变量
例子中 String str = "";//局部变量 为实例变量，
static String strr = "nihao"; 为 静态变量， 变量前加 static 即为 静态变量，可跨类
还可以使用 类名.静态变量 来调用
四、运算符
1. 等号=
int a,b, c;
c = 0;// 从 最右边的 = 的右边 开始处理
a = b = c = 4;// c4赋值给c， c赋值给b， b赋值给a//但不建议这样用
2.自增自减
自增自减，必须是整型或者 浮点型(c++没这个)，加减1的意思
int a = 4;
int b = a++;// 运算结果，a=4 b=5
3.逻辑运算符： 表达式结果为 boolean类型，真或假
&& 、 & 都表示 逻辑与
例子： boolean p1 = false; boolean p2 = true;
p1& p2必须把p1 p2两边表达式都算完后，才能算出整个表达式的结果；没有短路的功能
p1&& p2有短路的功能, 此处 p1为false，则后面就不用看p2了，表达式结果为false
4.位运算符
& 按位与
| 按位或
~ 按位取反
^ 按位异或
<< 左移( --->>箭头)
>>右移
>>> 无符号右移 无论最高位是0还是1，左侧被移空的高位填 0
注意：移位运算只限于 整型类型
了
5.三元运算
boolean a = 20 > 0 ? true : false;
6.运算符的优先级
自增自减 > 算术运算 > 比较运算 > 逻辑运算 > 赋值运算
7.类型转换
强制类型转换
五、流程控制
if for while 等就不在记录了。本文中只简单记录一下重点知识。
switch中 case中常量名称必须不相同。
foreach的增强语法：就是 for( : );;;实际上 是没有foreach这个关键词的，我在初学时一直用foreach，然后编译器却说foreach未定义，就是因为没有这个关键词，还是用for弄出来的
int arr2[] = {1,2,3,4,5};//初始化
for(int i : arr2)
{
System.out.print("元素：" + i+ "\r\n");
}
六、字符串
String s;//声明的字符串必须初始化之后才能用，否则编译器会报错
1.创建字符串
(1) String(char [])
char a[] = {'g','o','o','d'};
String newSt = new String(a);
//上面等价于
//String newSt = new String("good"); 跟上句一个意思
String newSt2 = new String(a, 1,2);//输出 oo(2)String(char[], 开始位置, 截取长度)
char a[] = {'g','o','o','d'};
String newSt = new String(a);
//上面等价于
//String newSt = new String("good"); 跟上句一个意思
String newSt2 = new String(a, 1,2);//输出 oo(3)直接字符串赋值
String str = "是我学习Java语言的最佳书籍";2.连接字符串
使用 + 即可
3.字符串常用属性
String str = "是我学习Java语言的最佳书籍";(1)长度 str.length()
(2)查找
str.indexOf() 返回的是首次出现的位置
str.LastIndexOf 返回的是最后一次出现的位置
(3)获取指定位置的字符
char ch = str.charAt(int nindex)
(4)截取字符串 substring
String str = "";
char a[] = {'g','o','o','d'};
String newSt = new String(a);
//上面等价于
//String newSt = new String("good"); 跟上句一个意思
String newSt2 = new String(a, 1,2);//输出 oo
String str1 = newSt.substring(1);// str1=ood 从第1个开始，直到字符串结束
String str2 = newSt.substring(1,3);// str1=ood 从位置1个开始，到位置3个结束
String str3 = newSt.trim();//去除字符串前后的空格
(5)字符串 替换replace
(6)判断字符串的开始与结尾
boolean b1 = newSt.startsWith("go");//以XX为开头
boolean b2 = newSt.endsWith("od");//XX为结尾(7)判断字符串是否相等
不能以==进行简单的判断，即使字符串内容相同，但其内存地址也不同。
equals()//比较字符串，区分大小写----》返回值为 boolean
equalsIgnoreCase()//比较字符串，不区分大小写---》返回值为 boolean
int b5 = str1.compareToIgnoreCase(str2);//比较字符串，不区分大小写 ---》返回值为 int
int b6 = str1.compareTo(str2);//比较字符串，区分大小写 ---》返回值为 int
boolean b3 = str1.equals(str2);//比较字符串，区分大小写
boolean b4 = str1.equalsIgnoreCase(str2);//比较字符串，不区分大小写
//按照字典顺序进行比较，只有当字符串一样时，才返回0， 其他有正值，有负值
int b5 = str1.compareToIgnoreCase(str2);//比较字符串，不区分大小写
int b6 = str1.compareTo(str2);//比较字符串，区分大小写(8)字符串分割 split
String strCondext = "alsdj-shfh,sdhg=skdh";
strCondext.split("-|=|,");//分割符号为- = , 三个分隔符进行分割//多个分隔符用 |
String strCondextIP = "192.168.100.144";
String[] fisrtSplit = strCondextIP.split("\\.");//使用.进行分割//数组 [192] [168][100][144]
String[] secondSplit = strCondextIP.split("\\.", 2);//使用.进行分割//数组 [192] [168.100.144]
(9)字符串格式化Format
(10)正则表达式
(11)字符串生成器StringBuilder---创建不定长的字符串
程序中如果不断的添加字符串，则建议使用StringBuilder
七、数组
1.定义
下标从0开始的
int arr[] = new int[5];//分配内存//数组中元素初始值为0
int arr1[] = new int[]{1,2,3,4,5};//初始化
int arr2[] = {1,2,3,4,5};//初始化
int av[] = new int[]{1,2,3,4,5};
for(int i : arr2)
{
System.out.print("元素：" + i+ "\r\n");
}
int arr22[][] = {{1,2,3},{4,5,6}};//二维数组的初始化2.操作
java.util包含了Array类的所有操作
(1)数组填充fill
fill(数组, 值);//对数组a 整个赋值为5
int arr2[] = {1,2,3,4,5};//初始化
Arrays.fill(arr2, 99);
for(int i : arr2)
{
System.out.print("元素：" + i+ "\r\n");
}(2)数组排序sort
Array类的其他方法请参考书籍《Java从入门到精通》
(3)数组查询
binarySearch(Object[], Object key)
binarySearch(Object[],int fromindex,int tolndex,Object key)
使用数组查询之前必须先对数组排序sort, 返回结果为排序后的数组元素所在的位置
八、类和对象
类：封装、继承、多态，与c++类似，不在赘述
Java类的默认访问权限是包级私有（package-private）。Java类的默认访问权限是包级私有，它限制了类的访问范围仅限于同一个包中的其他类。这种访问权限的设定有助于实现封装和模块化，提高代码的可维护性和安全性。
this关键字： this引用的就是本类的一个对象 this.name = name;
类的构造方法(c++叫构造函数)：与类名相同，没有返回值，函数自动调用；若没有定义构造方法，程序会自动创建一个不带参数的构造方法。
1.静态成员
2.不能将方法中的局部变量声明为static类型
3.类的主方法
主方法是类的入口点，定义了程序从何处开始，控制整个程序的流程。
4.对象
(1)对象的创建：
(2)访问对象的属性和方法
对象.类成员
(3)对象的引用
(4)对象的销毁
自动回收机制，不需要手动释放，但只能回收由 new 创建的对象。
finalize()来实现非new创建的对象。
5.类中默认权限为 包级私有
九、包装类
十、数字处理类
导入库： import java.text.DecimalFormat;
DecimalFormat类，是NumberFormat的一个子类，用于格式化十进制数字。
1.随机数：
Math.Random
还有java.util.Random类
Random r=new Random();
2.大数字运算
在Java 中提供了大数字的操作类，即java.math.BigInteger 类与java.math.BigDecimal类。这两个类用于高精度计算，其中 BigInteger 类是针对大整数的处理类，而 BigDecimal类则是针对大小数的处理类.
下面为核心技术
十一、接口、继承(extend)、多态
//父类
class Testsc{
public Testsc()
{
System.out.print("父类构造" );
}
protected void DoSomthing()
{
;
}
protected Testsc DoIdlt()
{
return new Testsc();
}
}
//子类
class Testsc_sub extends Testsc{ //extends关键字为继承
public Testsc_sub()
{
super();//调用父类构造方法
super.DoSomthing();//调用父类的成员函数
System.out.print("子类构造" );
}
protected void DoSomthing()//重写父类方法
{
;
}
public void DoSomthingNew()//新增函数
{
;
}
public Testsc_sub DoIdlt()//重写父类方法//子类重写时，权限只能升级，不能降级，不能由protected变为private
{
return new Testsc_sub();
}
}调用构造方法的顺序，首先是顶级父类，然后是上一级父类最后是子类。也就是说，实例化子类对象时首先要实例化父类对象，然后再实例化子类对象，所以在子类构造方法访问父类的构造方法之前，父类已经完成实例化操作。
instanceof 向下转型时需要使用
不定长参数
private int Add(int···a)；//int···a 实际上是一个数组
抽象与接口
abstract定义抽象类的关键字，只要类中有一个抽象方法，此类就被标记为抽象类。抽象类被继承后，要重写所有的抽象方法。类不能同时继承多个父类，只能有一个父类，由此出现了接口。
使用interface定义接口类，必须为public，没有定义时默认为public，接口类中没有方法体，接口类中可以实现多重继承。
十二、java的高级特性
用package创建包，包的名称要使用小写字母。
1. import导入包
(1)import导入包
import com.lzw.Math//指定com.lzw包中的Math类在程序中可以使用如果想使用包中更多的类，可以 加 *
import com.lzw.*//(2).import导入静态成员变量
import static java.lang.System.out;具体代码如下：
package helloJava;
import java.util.*;
import static java.lang.System.out;
public class helloMain {
public static void main(String[] args) {
System.out.print("《Java入门到精通》！" + "\r\n" );
out.print("nihao!你好");
//System.out.print(secondSplit);
}
}
2.final 常量
final double PI = 3.1415926;
private final int value_1 = 15;//声明一个final常量
private static final int value_2 = 1455;//声明一个final、 static 常量
private final Testsc_sub test = new Testsc_sub();//声明一个final引用
private Testsc_sub test2 = new Testsc_sub();//声明一个不是final引用
private final int a = {1,2,3,4,5,6};//声明一个定义为final的数组注意下面a1与a2的值
package helloJava;
import static java.lang.System.out;
import java.util.*;
public class helloMain {
String str = "";
int au = 0;
private final int value_1 = 15;//声明一个final常量
private static final int value_2 = 1455;//声明一个final、 static 常量
private final Testsc_sub test = new Testsc_sub();//声明一个final引用
private Testsc_sub test2 = new Testsc_sub();//声明一个不是final引用
private final int avu[] = {1,2,3,4,5,6};//声明一个定义为final的数组
//必须加static 否则会报错
public static class FinalStaticData{
private static Random randm = new Random();//实例化一个randm对象
//随机产生一个0-10的值给final a1
private final int a1 = randm.nextInt(10);非static
//随机产生一个0-10的值给static final a2
private static final int a2 = randm.nextInt(10);static
}
public static void main(String[] args) {
java.lang.System.out.print("nihao!你好");
FinalStaticData fData = new FinalStaticData();//实例化一个对象
out.print("1重新实例化对象调用a1的值: " + fData.a1 + "\r\n");
out.print("1重新实例化对象调用a2的值: " + fData.a2 + "\r\n");
//实例化另外一个对象
FinalStaticData fData2 = new FinalStaticData();//实例化一个对象
out.print("2重新实例化对象调用a1的值: " + fData2.a1 + "\r\n");
out.print("2重新实例化对象调用a2的值: " + fData2.a2 + "\r\n");
}
}
输出：注意看无论实例化哪个对象，其a2的值都是一样的
nihao!你好1重新实例化对象调用a1的值: 5
1重新实例化对象调用a2的值: 1
2重新实例化对象调用a1的值: 6
2重新实例化对象调用a2的值: 13.定义为final的方法不能被重写P206
防止子类重写该方法，且执行效率比非final效率高。
如果父类某些方法设置为private，则子类无法访问该方法，所以一个被定义为private的方法被指定为final类型。所以，不需要对private的方法设置为final类型。
4.定义为final的类不能被继承
如果类定义为final类，则类中方法和成员变量隐式的变成了final类型。
5.局部内部类
局部类是指定义在类内部的类。
//定义一个接口
interface parentCalss{
}
public parentCalss doit(final String x){
class innerClass implements parentCalss{
innerClass(String s)//innerclass为局部内部类
{
s = x;
System.out.print(s);
}
}
return new innerClass("doit") ;
}6匿名类
//定义一个接口
interface parentCalss{
}
class OuterClass4{
public parentCalss doit()
{
//匿名类，类没有名称
return new parentCalss() {
private int i = 0;
public int getValue()
{
return i;
}
};
}
}
常用 的匿名类的规范
// //匿名类的规范
return new A() {
....;//内部类体
}7.静态内部类
内部类之前加static就变成了静态内部类，静态内部类在开发中比较少。
静态类的特点：
1.静态内部类中可加static定义静态成员，但不允许在非静态类内部类中定义静态成员。
2.静态内部类不可以使用外部类的非静态成员
例子：
8.内部类的继承
十三、异常处理
1.基础知识
try catch finally 捕获异常，常用格式如下：
try{}
catch(ExceptionType1 e1){}
catch(ExceptionType2 e2){}
finally{}
2.自定义异常
3.方法中抛出异常throw
4.使用关键字throw抛出异常
java.lang.ArithmeticException是Java中的一个运行时异常类，它继承自java.lang.RuntimeException类。该异常表示在数学运算中发生了算术错误或不合法的操作。
5.运行时异常
RuntimeException异常。 Throwable类派生了两个子类，分别为Exception 和 error类。
Error类描述java运行系统中的内部错误以及资源耗尽的错误
Exception为非致命性类，可以通过捕捉处理是程序继续执行。
Exception根据错误发生的原因分为RuntimeException异常 和除RuntimeException之外的异常。
十四、swing程序设计
AWT抽象窗口工具箱 swing在不同平台上显示风格统一 GUI图形用户界面
1.JFrame窗体
JFrame窗体是一个容器它是Swing程序中各个组件的载体。在开发应用程序时可以通过继承java.swing.JFrame类创建一个窗体
例子：
package helloframe;
import java.awt.*;//导入awt包
import javax.swing.*;//导入swing包
//修改此处，改为extends继承类
public class Example1_frame extends JFrame{//定义一个类继承JFrame
public void CreateJFrame(String strtile) {//定义一个方法
JFrame jFrame = new JFrame(strtile);//实例化一个JFrame对象
Container container = jFrame.getContentPane();//获取一个容器
JLabel jLabel = new JLabel("这事一个JFrame窗体");//创建一个标签
jLabel.setHorizontalAlignment(SwingConstants.CENTER);//居中
jLabel.setForeground(Color.red);//设置字体颜色
container.add(jLabel);//将标签添加到容器中
container.setBackground(Color.black);//设置容器背景色
jFrame.setVisible(true);//可见
jFrame.setSize(400, 250);//窗体大小
jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
//执行体
public static void main(String[] args) {
// TODO Auto-generated method stub
new Example1_frame().CreateJFrame("hello world");
}
}
2.JDialog：
从一个窗体中弹出另一个窗体
package helloframe;
import java.awt.*;//导入awt包
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;//导入swing包
import javax.swing.text.Position.Bias;
//修改此处，改为extends继承类
public class Example1_frame extends JFrame{//定义一个类继承JFrame
class myDialog extends JDialog{
public myDialog (Example1_frame frame) {
super(frame, "第一个Jdialog窗体", true);
Container container = getContentPane();
container.add(new JLabel("这事一个对话框2"));
setBounds(20, 20, 300,300);
}
}
public Example1_frame() {
JFrame jFrame = new JFrame("主窗体");//要想有窗体，必须有这个frame否则看不到窗体
Container container = jFrame.getContentPane();
container.setLayout(null);
JLabel jLabel = new JLabel("这是一个就frame窗体");
jLabel.setHorizontalAlignment(SwingConstants.CENTER);
container.add(jLabel);
JButton bl = new JButton("弹出对话框");
bl.setBounds(20, 20, 150,150);
//为鼠标添加单击响应
bl.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
new myDialog(Example1_frame.this).setVisible(true);
}
});
container.add(bl);
jFrame.setVisible(true);
jFrame.setSize(400, 400);
jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
}
// public void CreateJFrame(String strtile) {//定义一个方法
// JFrame jFrame = new JFrame(strtile);//实例化一个JFrame对象
// Container container = jFrame.getContentPane();//获取一个容器
// JLabel jLabel = new JLabel("这事一个JFrame窗体");//创建一个标签
// jLabel.setHorizontalAlignment(SwingConstants.CENTER);//居中
// jLabel.setForeground(Color.red);//设置字体颜色
// container.add(jLabel);//将标签添加到容器中
// container.setBackground(Color.black);//设置容器背景色
// jFrame.setVisible(true);//可见
// jFrame.setSize(400, 250);//窗体大小
// jFrame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//
// }
//执行体
public static void main(String[] args) {
// TODO Auto-generated method stub
//new Example1_frame().CreateJFrame("hello world");
new Example1_frame();
}
}
十五、I/O技术
I/O技术可将数据存储到文本文件、二进制文件、甚至压缩文件中。相应的函数在java.io包中。
InputStream OutputStream 处理字节
Reader Writer 处理字符
File 文件类，跨平台， 创建、删除、重命名
FileInputStream FileOutputStream 字节，带中文的可能会乱码
FileReader FileWriter 字符，带中文也可以
带缓存的输入、输出流
BufferedInputStream BufferedOutputStream 字节，带中文的可能会乱码
BufferedReader BufferedWriter 字符，带中文也可以
十七、多线程
线程所在包：import java.lang.*;
1.多线程实现方式
(1)继承Thread类
定义新类：
public class ThreadTest extends Thread{
private int ncount = 100;
public void run()
{
while((ncount > 0))
{
System.out.print("ncount = " + ncount + "\r\n");
ncount--;
}
}
}调用的地方：
new ThreadTest().start();(2)实现Runnable类
定义新类
public class ThreadRuna implements Runnable{
private int num = 10;
public void run() {
while(true)
{
if(num > 0)
{
try {
Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
System.out.print("ticks: " + num-- + "\r\n");
}
}
}
}调用的地方：
ThreadRuna t = new ThreadRuna();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
Thread t3 = new Thread(t);
Thread t4 = new Thread(t);
t1.start();
t2.start();
t3.start();
t4.start();实现方式2中会出现num=1有多个的情况，或者出现num有负数的情况
ticks: 9
ticks: 10
ticks: 7
ticks: 8
ticks: 6
ticks: 4
ticks: 5
ticks: 6
ticks: 3
ticks: 2
ticks: 3
ticks: 3
ticks: 1
ticks: 1
ticks: 1
ticks: 12.多线程的同步---synchronized同步块---效果不行，为什么不行啊？？？？？？？？
上面实现方式2添加线程的同步，实现多个线程访问同一个资源时保证数据安全有效
public class ThreadRuna implements Runnable{
int num = 10;
public void run() {
while(true)
{
if(num > 0)
{
//添加同步块
synchronized ("") {
try {
Thread.sleep(100);
} catch (Exception e) {
// TODO: handle exception
e.printStackTrace();
}
System.out.print("ticks: " + num + "\r\n");
num--;
}
}
}
}
}结果还是有负数
ticks: 10
ticks: 9
ticks: 8
ticks: 7
ticks: 6
ticks: 5
ticks: 4
ticks: 3
ticks: 2
ticks: 1
ticks: 0
ticks: -1
ticks: -2
3.方法同步 synchronized void f()
十八、网络通信
图片来自于书籍：《来自于： 《Java从入门到精通》》
14万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
