<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[wisdomcodeinside的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/wisdomcodeinside</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; wisdomcodeinside]]></copyright><item><title><![CDATA[Java多线程3 线程的同步]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104742237</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104742237</guid><author>wisdomcodeinside</author><pubDate>Sun, 08 Mar 2020 22:19:16 +0800</pubDate><description><![CDATA[/*
Java多线程： 线程的生命周期与线程安全
一，线程的分类
Java中的线程分为两类：一种是守护线程，一种是用户线程。 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
Java垃圾回收和异常处理就是典型的守护线程，main方法时用户线程...]]></description><category></category></item><item><title><![CDATA[Java多线程2 线程创建的两种方式与Thread类常用方法]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104704990</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104704990</guid><author>wisdomcodeinside</author><pubDate>Fri, 06 Mar 2020 21:37:57 +0800</pubDate><description><![CDATA[/*
线程的创建方式
一 Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来体现。
Thread类的特性
1，每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常
把run()方法的主体称为线程体
2，通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
3，构造器
*Thread()：创建新的Thread对象
*...]]></description><category></category></item><item><title><![CDATA[Java 多线程1 IDEA快捷键和多线程的理解]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104642954</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104642954</guid><author>wisdomcodeinside</author><pubDate>Tue, 03 Mar 2020 22:05:11 +0800</pubDate><description><![CDATA[package leanthread;/*
ideal 常用快捷键
https://blog.youkuaiyun.com/houfeng30920/article/details/79037647

-----------自动代码--------
常用的有fori/sout/psvm+Tab即可生成循环、System.out、main方法等boilerplate样板代码
例如要输入for(User user...]]></description><category></category></item><item><title><![CDATA[java练习项目三 团队成员调度程序]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104582578</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104582578</guid><author>wisdomcodeinside</author><pubDate>Sat, 29 Feb 2020 21:46:06 +0800</pubDate><description><![CDATA[主要目的，练习多态性，异常处理，设计模式
创建bean包，包含基础对象
创建员工类
package bean;

public class Employee {
  private int id;
  private String name;
  private int age;
  private double salary;
public int getId() {
	return id;
}...]]></description><category></category></item><item><title><![CDATA[java异常4 手动抛出异常与自定义异常类]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104506582</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104506582</guid><author>wisdomcodeinside</author><pubDate>Tue, 25 Feb 2020 21:59:56 +0800</pubDate><description><![CDATA[/*

手动抛出异常：throw（注意throws是处理异常，throw是抛出异常）

1，Java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要使用人工创建并抛出。

2首先要生成异常类对象，然后通过throw语句实现抛出操作(提交给Java运行环境)。
可以抛出的异常必须是Throwable或其子类的实例。否则将会产生语法错误：
通常使用RuntimeExceptio...]]></description><category></category></item><item><title><![CDATA[java异常3异常处理之throws结构]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104500280</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104500280</guid><author>wisdomcodeinside</author><pubDate>Tue, 25 Feb 2020 16:43:13 +0800</pubDate><description><![CDATA[/*
*异常处理方式2 throws
*

1，throws + 异常类型写在方法的声明处，指明此方法执行时，可能会抛出的异常。
当方法执行出现异常时，会在异常处生成一个异常类的对象，当此对象匹配到throws后声明的异常类型
时，就会被抛出，由此方法的调用者处理异常，异常代码之后的语句不再执行。
2，throws后面的异常类型可以有多个，使用,隔开。异常类型可以是方法中产生的异常类型，也可以是它...]]></description><category></category></item><item><title><![CDATA[java异常2 异常处理之try-catch-finally结构]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104494511</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104494511</guid><author>wisdomcodeinside</author><pubDate>Tue, 25 Feb 2020 11:50:13 +0800</pubDate><description><![CDATA[/*

异常处理方式1 try-catch-finally

1，Java采用的异常处理机制，是将异常处理的程序代码集中在一起，与正常的程序代码分开，
过多的if-else分支会导致程序的代码加长、臃肿，可读性差。因此采用异常处理机制。使得程序简洁、优雅，并易于维护。

2，Java提供的是异常处理的抓抛模型。
步骤一：抛出异常
程序在执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交...]]></description><category></category></item><item><title><![CDATA[java异常1 异常概述与分类]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104480078</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104480078</guid><author>wisdomcodeinside</author><pubDate>Mon, 24 Feb 2020 16:32:49 +0800</pubDate><description><![CDATA[/*

异常的概述与分类

1，在Java语言中，将程序执行中发生的不正常情况称为“异常”。 (开发过程中的语法错误和逻辑错误不是异常)

2，Java程序在执行过程中所发生的广义异常事件可分为两类：
2.1Error(也叫错误)：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。
比如：StackOverflowError和OutOfMemoryError。一般不编写...]]></description><category></category></item><item><title><![CDATA[java前期补遗--编译过程与关键字的书写规范]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104458140</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104458140</guid><author>wisdomcodeinside</author><pubDate>Sun, 23 Feb 2020 12:45:50 +0800</pubDate><description><![CDATA[/*
1.java程序编写-编译-运行的过程
编写：将编写的java代码保存在以.java为后缀的源文件中
编译：使用java.exe命令编译java源文件。格式为 javac 源文件名.java
运行：使用java.exe命令解释运行我们的字节码文件。格式： java 类名
2.在一个java源文件中可以声明多个class，但是最多只能有一个类被声明为public
被声明的类名称应该跟文件名一致...]]></description><category></category></item><item><title><![CDATA[java前期补遗--运算符的使用]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104458112</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104458112</guid><author>wisdomcodeinside</author><pubDate>Sun, 23 Feb 2020 12:43:48 +0800</pubDate><description><![CDATA[/*
java中的运算符
1，算数运算符
正+负- 加+ 减-乘*除/ 取模%
自增（前）++a 先运算后取值 自增（后）a-- 先取值后运算
自减（前）–a 先运算后取值 自减（后）a-- 先取值后运算
字符串连接+
*/
class ArythmeticTest{
	public static void main(String[] args) {
	//除法 / 
	int num1 = 12...]]></description><category></category></item><item><title><![CDATA[java前期补遗--基本数据类型与自动类型提升]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104457997</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104457997</guid><author>wisdomcodeinside</author><pubDate>Sun, 23 Feb 2020 12:36:23 +0800</pubDate><description><![CDATA[/*
java定义的数据类型
java属于强类型语言，对于每一种数据都定义了明确的具体类型，并在内存中分配不同大小的内存空间。
按照数据类型分
一，基本数据类型（primitive type）
1数值型（整数型 byte short int long，浮点型float double）内存空间有小到大
2字符型 char
3布尔型 boolean
二，引用数据类型（reference type）
1...]]></description><category></category></item><item><title><![CDATA[java面向对象24 内部类（InnerClass）的使用]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104455753</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104455753</guid><author>wisdomcodeinside</author><pubDate>Sun, 23 Feb 2020 10:30:01 +0800</pubDate><description><![CDATA[/*

类成员结构之内部类的使用

1，Java中可以在一个类A中定义一个类B，类A为外部类，类B为内部类，
注意内部类B的类名不能与外部类A重名
编译以后生成 外部类名$内部类名.class字节码文件

2，内部类按照声明的位置分为：
成员内部类(静态的与非静态的)
1，作为外部类的成员


可以调用外部类的结构




不同于外部类不能被static修饰，内部类可以声明为static的。


...]]></description><category></category></item><item><title><![CDATA[java面向对象23 JDK8中关于接口的新特性]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104430717</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104430717</guid><author>wisdomcodeinside</author><pubDate>Fri, 21 Feb 2020 16:56:15 +0800</pubDate><description><![CDATA[/*

JDK8中关于接口的新特性

JDK8以后的版本中接口内的结构除了可以定义全局常量和抽象方法外，还可以定义静态方法与默认方法

静态方法：使用 static 关键字修饰。可以通过接口直接调用静态方法，并执行其方法体。经常在相互一起使用的类中使用静态方法。
可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。

默认方法：默认方法使用 ...]]></description><category></category></item><item><title><![CDATA[java面向对象22 接口的应用：工厂模式]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104427276</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104427276</guid><author>wisdomcodeinside</author><pubDate>Fri, 21 Feb 2020 14:22:31 +0800</pubDate><description><![CDATA[/*

接口的应用：工厂模式

1工厂模式：实现了创建者与调用者的分离，即将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。
用工厂方法代替 new 操作。将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

2工厂模式的分类：
2.1简单工厂模式：用来生产同一等级结构中的任意产品。
简单工厂模式也叫静态工厂模式，就是工厂类一般是使用静态方法，通过接收的参数的不同来返回不...]]></description><category></category></item><item><title><![CDATA[java面向对象21接口interface的使用]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104423293</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104423293</guid><author>wisdomcodeinside</author><pubDate>Fri, 21 Feb 2020 10:11:46 +0800</pubDate><description><![CDATA[/*

接口（interface）的使用

1，使用 interface 接口名{} 的格式来定义一个接口，接口的主要用途就是被实现类实现。（面向接口编程）

2，在java中接口与类是并列的结构，

3，接口里面的成员
3.1在JDK7及以前的版本中，接口里面只能定义全局常量和抽象方法


全局常量：public static final 变量类型 变量名 = 值;因为默认是公共的静态常量，前面...]]></description><category></category></item><item><title><![CDATA[java面向对象20抽象类abstract的使用]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104396168</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104396168</guid><author>wisdomcodeinside</author><pubDate>Wed, 19 Feb 2020 16:57:37 +0800</pubDate><description><![CDATA[/*

抽象类与抽象方法，abstract关键字

abstract可以修饰类与方法，不能t修饰变量、代码块、构造器，
不能用abstract修饰私有方法、静态方法、final的方法、final的类。

1,用abstract关键字来修饰一个类，这个类叫做抽象类.
1.1抽象类不能被实例化
1.2类中一定要有构造器，便于子类实例化时调用。
1.3应用中都会提供抽象类的子类，让子类对象实例化。

2...]]></description><category></category></item><item><title><![CDATA[java面向对象19 final关键字的使用]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104352780</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104352780</guid><author>wisdomcodeinside</author><pubDate>Mon, 17 Feb 2020 09:09:43 +0800</pubDate><description><![CDATA[/*

final关键字的使用

在Java中声明类、变量和方法时，可使用关键字final来修饰,表示“最终的”。
1,当用final来修饰一个类时，此类不能被继承，例如：String，System，StringBuffer。
2，当用final来修饰一个方法时，此方法无法被重写，例如Object类中的getClass().
3,当用final来修饰一个变量时，表明此为常量，值无法修改
3.1当f...]]></description><category></category></item><item><title><![CDATA[java面向对象18 代码块的使用]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104331030</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104331030</guid><author>wisdomcodeinside</author><pubDate>Sat, 15 Feb 2020 17:15:51 +0800</pubDate><description><![CDATA[/*

类成员之代码块

代码块也叫初始化块，作用是对Java类或对象进行初始化
一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块(static block)，没有使用static修饰的，为非静态代码块。

静态代码块


可以有输出语句。




可以对类的属性、类的声明进行初始化操作。




不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。




若有多个静...]]></description><category></category></item><item><title><![CDATA[java个人项目，股票资金模拟]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104314342</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104314342</guid><author>wisdomcodeinside</author><pubDate>Fri, 14 Feb 2020 16:28:59 +0800</pubDate><description><![CDATA[第一个版本在学习java面向对象之前编写，比较初级，直接在控制台输入参数，在main方法中完成数据的模拟与输出
package stocktradingsimulation;
/*
此程序用于虚拟股票交易数值结果，模拟四只股票的交易情况
@author:wisdomcodeinside
@version:1.0.0.1
*/

import java.util.Scanner;
import ja...]]></description><category></category></item><item><title><![CDATA[java面向对象17static关键字与单例模式]]></title><link>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104307055</link><guid>https://blog.youkuaiyun.com/wisdomcodeinside/article/details/104307055</guid><author>wisdomcodeinside</author><pubDate>Fri, 14 Feb 2020 09:49:23 +0800</pubDate><description><![CDATA[/*

static关键字的使用
1,static(静态的)，关键字可以用来修饰属性，方法，代码块，内部类，不能用来修饰构造器

2,使用static修饰属性：静态变量，或者叫类变量
2.1属性按照是否使用static修饰分为静态属性（类属性）和非静态属性（实例变量）。
实例变量：创建类的多个对象，每个对象都有独立的一套类中的非静态属性，修改其中一个对象的
非静态属性不影响其他的对象，不会导致其他...]]></description><category></category></item></channel></rss>