3 weeks ago · aa66bb91b8
--- a/html&css&javaScriptProject/JavaScriptDemo/dom/demo01.html
+++ b/html&css&javaScriptProject/JavaScriptDemo/dom/demo01.html
@@ -0,0 +1,32 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+    <style>
			
 
				+        div{
			
 
				+            width: 300px;
			
 
				+            height: 300px;
			
 
				+            margin: 10px auto;
			
 
				+            background-color: red;
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <div id="myDiv">
			
 
				+
			
 
				+    </div>
			
 
				+<script>
			
 
				+
			
 
				+    let myDiv = window.document.getElementById("myDiv");
			
 
				+    myDiv.onmouseover=function (){
			
 
				+        console.log("鼠标移入了div框")
			
 
				+    }
			
 
				+    myDiv.onmouseout=function (){
			
 
				+        console.log("鼠标移出了div框........")
			
 
				+    }
			
 
				+    console.log(location.host);
			
 
				+
			
 
				+</script>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/JavaScriptDemo/js/myjs.js
+++ b/html&css&javaScriptProject/JavaScriptDemo/js/myjs.js
@@ -0,0 +1 @@
 
				+alert("我还是个弹窗")
			
--- a/html&css&javaScriptProject/JavaScriptDemo/jsDemo01.html
+++ b/html&css&javaScriptProject/JavaScriptDemo/jsDemo01.html
@@ -0,0 +1,25 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+    <!--内嵌JavaScript代码-->
			
 
				+    <script>
			
 
				+        /*这里面就可以写JavaScript代码了*/
			
 
				+        alert("我是一个弹窗....444444")
			
 
				+    </script>
			
 
				+    <!--引入外部script文件-->
			
 
				+    <script src="./js/myjs.js"></script>
			
 
				+</head>
			
 
				+<body>
			
 
				+
			
 
				+<!--引入外部script文件-->
			
 
				+<script src="./js/myjs.js"></script>
			
 
				+
			
 
				+<!--当把JavaScript代码写在body标签中，一般写在最后。-->
			
 
				+<script>
			
 
				+    /*这里面就可以写JavaScript代码了*/
			
 
				+    alert("我是一个弹窗....1")
			
 
				+</script>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/JavaScriptDemo/jsDemo02.html
+++ b/html&css&javaScriptProject/JavaScriptDemo/jsDemo02.html
@@ -0,0 +1,26 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+    <head>
			
 
				+        <meta charset="UTF-8">
			
 
				+        <title>Title</title>
			
 
				+    </head>
			
 
				+    <body>
			
 
				+    <!--
			
 
				+        浏览器可以分为两部：
			
 
				+            渲染引擎：用来解析HTML和CSS，也就是浏览器内核
			
 
				+            JS引擎：用来读取网页中的JavaScript代码，也就是JS解释器。
			
 
				+            浏览器本身不会执行JS代码，是通过内置的JavaScript引擎来解释并执行代码。
			
 
				+    -->
			
 
				+        <script>
			
 
				+            /*在浏览器中出现一个弹窗*/
			
 
				+            alert("我是一个弹窗");
			
 
				+            /*在控制台中输出一段内容*/
			
 
				+            console.log("我是控制台中的一段文字...");
			
 
				+            /*在网页中输出一段文字*/
			
 
				+            document.write("Hello JavaScript")
			
 
				+            document.write("<h1>Hello JavaScript</h1>")
			
 
				+            /*可以输入的弹窗*/
			
 
				+            prompt("你今年几岁？")
			
 
				+        </script>
			
 
				+    </body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/JavaScriptDemo/jsDemo03.html
+++ b/html&css&javaScriptProject/JavaScriptDemo/jsDemo03.html
@@ -0,0 +1,36 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <script>
			
 
				+        /*
			
 
				+            声明变量
			
 
				+            格式： var 变量名=变量值;
			
 
				+            JavaScript是弱类型语言，js中的变量类型可以根据变量值自动的配置类型
			
 
				+         */
			
 
				+        var a;
			
 
				+        console.log(a);
			
 
				+        console.log(typeof(a))
			
 
				+        a=6;  /*整数*/
			
 
				+        /*typeof()函数判断括号内的变量的类型，typeof关键字 判断后面的变量的类型*/
			
 
				+        console.log(typeof(a))
			
 
				+        a="哈哈哈哈" /*字符串类型*/
			
 
				+        console.log(typeof a)
			
 
				+        a=3.14; /*小数*/
			
 
				+        console.log(typeof(a))
			
 
				+        a=true;
			
 
				+        console.log(typeof(a))
			
 
				+        // 控制台输出： console.log();
			
 
				+        // 创建姓名、年龄、性别，变量，在控制台中输出
			
 
				+        // 创建a变量和b变量，交换两个变量的值。
			
 
				+        a=null;
			
 
				+        console.log(a)
			
 
				+        console.log(typeof(a))
			
 
				+        //任何的变量都有一个toString函数，把值转换为字符串
			
 
				+        a.toString();
			
 
				+    </script>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/JavaScriptDemo/jsDemo04.html
+++ b/html&css&javaScriptProject/JavaScriptDemo/jsDemo04.html
@@ -0,0 +1,32 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <script>
			
 
				+        /*创建JavaScript函数*/
			
 
				+        /*普通方式创建函数*/
			
 
				+        function myFun(a,b) {
			
 
				+            return a+b;
			
 
				+        }
			
 
				+        var myFun1 = myFun(16,80);
			
 
				+        console.log(myFun1);
			
 
				+        /*匿名函数，创建完必须立刻使用*/
			
 
				+        window.onload=function (){
			
 
				+            alert("浏览器界面加载完，我就被执行了")
			
 
				+        }
			
 
				+        /*函数表达式*/
			
 
				+       var myFun02 =function (){
			
 
				+            alert("浏览器界面加载完，我就被执行了")
			
 
				+        }
			
 
				+        myFun02();  //执行函数
			
 
				+
			
 
				+        //js里面的函数其实是属于 Function 对象的。
			
 
				+        //创建函数对象，得到函数
			
 
				+        var b = new Function('a','b','return a+b');
			
 
				+        var b1 = b(15,60);  //执行函数
			
 
				+    </script>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/JavaScriptDemo/jsDemo05.html
+++ b/html&css&javaScriptProject/JavaScriptDemo/jsDemo05.html
@@ -0,0 +1,57 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+    <script>
			
 
				+        /*创建Object对象，调用Object函数*/
			
 
				+        var obj = new Object();
			
 
				+        obj.a=15;
			
 
				+        obj.b=66;
			
 
				+        console.log(obj.a);
			
 
				+        console.log(obj.b);
			
 
				+
			
 
				+        /*正常的方式创建对象*/
			
 
				+        var obj1={
			
 
				+            name:"张三",
			
 
				+            age:25,
			
 
				+            sex:"男",
			
 
				+            eat:function (){
			
 
				+                return this.name+"在吃饭";
			
 
				+            }
			
 
				+        }
			
 
				+        console.log(obj1.name);
			
 
				+        console.log(obj1.age);
			
 
				+        console.log(obj1.sex);
			
 
				+        console.log(obj1.eat());
			
 
				+
			
 
				+        var person={
			
 
				+            name:"张三",
			
 
				+            age:25,
			
 
				+            sex:"男",
			
 
				+            eat:function (){
			
 
				+                return this.name+"在吃饭";
			
 
				+            }
			
 
				+        }
			
 
				+
			
 
				+        /*Math对象的常用方法*/
			
 
				+        var n1 = Math.max(15,8);
			
 
				+        console.log(n1);
			
 
				+
			
 
				+        var str="张三";
			
 
				+        str.substring(0,3);
			
 
				+
			
 
				+        var date=new Date();
			
 
				+        console.log(date)
			
 
				+
			
 
				+    </script>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/JavaScriptDemo/jsDemo06.html
+++ b/html&css&javaScriptProject/JavaScriptDemo/jsDemo06.html
@@ -0,0 +1,106 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+    <style>
			
 
				+        .mydiv01{
			
 
				+            margin: 100px auto;
			
 
				+            width: 300px;
			
 
				+            height: 300px;
			
 
				+            background-color: red;
			
 
				+        }
			
 
				+        button{
			
 
				+            width: 70px;
			
 
				+            height: 50px;
			
 
				+            color: #fff;
			
 
				+            background-color: #ff9500;
			
 
				+        }
			
 
				+        .mybtn{
			
 
				+            width: 143px;
			
 
				+        }
			
 
				+        .show{
			
 
				+            width: 290px;
			
 
				+            height: 50px;
			
 
				+            background-color: #0f0f00;
			
 
				+            color: #fff;
			
 
				+            font-size: 30px;
			
 
				+            text-align: right;
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <div class="show">0</div>
			
 
				+    <div>
			
 
				+        <button>7</button>
			
 
				+        <button>8</button>
			
 
				+        <button>9</button>
			
 
				+        <button>*</button>
			
 
				+    </div>
			
 
				+    <div>
			
 
				+        <button>4</button>
			
 
				+        <button>5</button>
			
 
				+        <button>6</button>
			
 
				+        <button>-</button>
			
 
				+    </div>
			
 
				+    <div>
			
 
				+        <button>1</button>
			
 
				+        <button>2</button>
			
 
				+        <button>3</button>
			
 
				+        <button>+</button>
			
 
				+    </div>
			
 
				+    <div>
			
 
				+        <button class="mybtn">0</button>
			
 
				+        <button>.</button>
			
 
				+        <button>3</button>
			
 
				+    </div>
			
 
				+
			
 
				+    <div>
			
 
				+        我的输入框： <input type="text" name="myText" class="myText" id="myText">
			
 
				+    </div>
			
 
				+
			
 
				+    <div class="mydiv01" id="mydiv01"></div>
			
 
				+    <div class="mydiv01" id="mydiv02"></div>
			
 
				+
			
 
				+    <script>
			
 
				+        //var 修饰符，是用来修饰变量的，var修饰的变量，这个变量就是全局变量。所有地方都可以访问它。
			
 
				+        //根据id获取DOM元素
			
 
				+        var myText = document.getElementById("myText");
			
 
				+        //获取焦点事件
			
 
				+        myText.onfocus=function (){
			
 
				+            console.log("我获得焦点了")
			
 
				+        }
			
 
				+        //失去焦点事件
			
 
				+        myText.onblur=function (){
			
 
				+            console.log("我失去焦点了")
			
 
				+        }
			
 
				+        //按下键盘后抬起事件
			
 
				+        myText.onkeyup=function (event){
			
 
				+            console.log(event);
			
 
				+            console.log(event.key); //获取按键的字符
			
 
				+        }
			
 
				+
			
 
				+
			
 
				+
			
 
				+        //根据class获取DOM元素的集合
			
 
				+        //var mydivs=document.getElementsByClassName("mydiv01");
			
 
				+        //var mydiv=mydivs[0];
			
 
				+        //let let修饰的变量就是局部变量，只有函数内部才能访问。
			
 
				+        let mydiv=document.getElementById("mydiv01");
			
 
				+        mydiv.onclick=function (){
			
 
				+            console.log("鼠标点击了这个div")
			
 
				+        }
			
 
				+        mydiv.ondblclick=function (){
			
 
				+            console.log("鼠标 双 击了这个div")
			
 
				+        }
			
 
				+
			
 
				+        mydiv.onmouseover=function (){
			
 
				+            console.log("鼠标移入这个div")
			
 
				+        }
			
 
				+        mydiv.onmouseout=function (){
			
 
				+            console.log("鼠标从这个div移出了")
			
 
				+        }
			
 
				+
			
 
				+    </script>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/JavaScriptDemo/计算器.html
+++ b/html&css&javaScriptProject/JavaScriptDemo/计算器.html
@@ -0,0 +1,160 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>计算器</title>
			
 
				+    <style>
			
 
				+        /*网页的格式化*/
			
 
				+        *{
			
 
				+            margin: 0;
			
 
				+            padding: 0;
			
 
				+            font-family: "Segoe UI";
			
 
				+            box-sizing: border-box;
			
 
				+        }
			
 
				+        body{
			
 
				+            background-color: #f0f0f0;
			
 
				+            display: flex;
			
 
				+            justify-content: center;
			
 
				+            align-items: center;
			
 
				+            padding: 20px;
			
 
				+        }
			
 
				+        .calculator{
			
 
				+            background-color: #000;
			
 
				+            border-radius: 15px;
			
 
				+            width: 100%;
			
 
				+            max-width: 400px;
			
 
				+            overflow: hidden;
			
 
				+            box-shadow: 0 10px 25px rgba(0,0,0,0.3);
			
 
				+        }
			
 
				+        .display{
			
 
				+            background-color: #222222;
			
 
				+            color: #fff;
			
 
				+            padding: 25px 20px;
			
 
				+            text-align: right;
			
 
				+            font-size: 30px;
			
 
				+            font-weight: 300;
			
 
				+            overflow-x: auto;
			
 
				+        }
			
 
				+        .buttons{
			
 
				+            display: grid;
			
 
				+            grid-template-columns: repeat(4,1fr);
			
 
				+            gap: 1px;
			
 
				+        }
			
 
				+        button{
			
 
				+            background-color: #666666;
			
 
				+            color: #fff;
			
 
				+            border: none;
			
 
				+            padding: 20px;
			
 
				+            font-size: 30px;
			
 
				+            transition: background-color 0.2s ease;
			
 
				+        }
			
 
				+        button:hover{
			
 
				+            background-color: #888;
			
 
				+        }
			
 
				+        button:active{
			
 
				+            background-color: #aaa;
			
 
				+        }
			
 
				+        .operator{
			
 
				+            background-color: #ff9500;
			
 
				+        }
			
 
				+        .operator:hover{
			
 
				+            background-color: #ffaa33;
			
 
				+        }
			
 
				+        .operator:active{
			
 
				+            background-color: #ffbb33;
			
 
				+        }
			
 
				+        .clear{
			
 
				+            background-color: #ff3b30;
			
 
				+        }
			
 
				+        .clear:hover{
			
 
				+            background-color: #ff4f40;
			
 
				+        }
			
 
				+        .clear:active{
			
 
				+            background-color: #ff8f80;
			
 
				+        }
			
 
				+        .zero{
			
 
				+            grid-column: span 2;
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <div class="calculator">
			
 
				+        <div class="display" id="display">0</div>
			
 
				+        <div class="buttons">
			
 
				+            <button class="clear" id="clear">C</button>
			
 
				+            <button class="operator" data-value="±">±</button>
			
 
				+            <button class="operator" data-value="%">%</button>
			
 
				+            <button class="operator" data-value="÷">÷</button>
			
 
				+
			
 
				+            <button data-value="7">7</button>
			
 
				+            <button data-value="8">8</button>
			
 
				+            <button data-value="9">9</button>
			
 
				+            <button class="operator" data-value="×">×</button>
			
 
				+
			
 
				+            <button data-value="4">4</button>
			
 
				+            <button data-value="5">5</button>
			
 
				+            <button data-value="6">6</button>
			
 
				+            <button class="operator" data-value="-">-</button>
			
 
				+
			
 
				+            <button data-value="1">1</button>
			
 
				+            <button data-value="2">2</button>
			
 
				+            <button data-value="3">3</button>
			
 
				+            <button class="operator" data-value="+">+</button>
			
 
				+
			
 
				+            <button class="zero" data-value="0">0</button>
			
 
				+            <button data-value=".">.</button>
			
 
				+            <button class="operator" data-value="=">=</button>
			
 
				+        </div>
			
 
				+    </div>
			
 
				+    <script>
			
 
				+        //获取DOM元素
			
 
				+        const display = document.getElementById("display");
			
 
				+        const clear = document.getElementById("clear");
			
 
				+        //获取所有的指定元素 获取带有data-value属性的所有元素
			
 
				+        const buttons=document.querySelectorAll("button[data-value]");
			
 
				+        //计算器的状态
			
 
				+        let currentValue="0";
			
 
				+        let operator=null;
			
 
				+        let resetOnNextInput=false;
			
 
				+
			
 
				+        //更新显示框操作
			
 
				+        function updateDisplay(){
			
 
				+            display.textContent=currentValue;
			
 
				+        }
			
 
				+
			
 
				+        //处理数字的输入
			
 
				+        function handleNumberInput(number){
			
 
				+            if (resetOnNextInput){
			
 
				+                currentValue=number;
			
 
				+                resetOnNextInput=false
			
 
				+            }else {
			
 
				+                // 0 == '0' true  0 === '0' false
			
 
				+                currentValue=currentValue === '0' ?number:currentValue+number;
			
 
				+            }
			
 
				+            //更新
			
 
				+            updateDisplay();
			
 
				+        }
			
 
				+
			
 
				+        //绑定事件监听器
			
 
				+        buttons.forEach(
			
 
				+            button =>{
			
 
				+                button.addEventListener('click',()=>{
			
 
				+                    const value=button.getAttribute("data-value");
			
 
				+                    if (!isNaN(value)||value==='0'){
			
 
				+                        handleNumberInput(value);
			
 
				+                    }else if(value === '.'){
			
 
				+                        //执行小数
			
 
				+                    }else if(value === '='){
			
 
				+                        //获取结果
			
 
				+                    }else {
			
 
				+                        //继续运算
			
 
				+                    }
			
 
				+                });
			
 
				+        });
			
 
				+
			
 
				+
			
 
				+
			
 
				+    </script>
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/html&css&javaScriptProject.iml
+++ b/html&css&javaScriptProject/html&css&javaScriptProject.iml
@@ -0,0 +1,8 @@
 
				+<?xml version="1.0" encoding="UTF-8"?>
			
 
				+<module type="WEB_MODULE" version="4">
			
 
				+  <component name="NewModuleRootManager" inherit-compiler-output="true">
			
 
				+    <exclude-output />
			
 
				+    <content url="file://$MODULE_DIR$" />
			
 
				+    <orderEntry type="sourceFolder" forTests="false" />
			
 
				+  </component>
			
 
				+</module>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo01-backgroundStyle.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo01-backgroundStyle.html
@@ -0,0 +1,75 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+    <!--
			
 
				+      在html文件里的<style>标签中写CSS样式，属于内部样式。如果CSS样式不是很多，并且不需要复用
			
 
				+      在css文件中写CSS样式，然后在html文件中使用<like>标签进行引入，属于外部引入样式。
			
 
				+      如果CSS样式非常多，并且可能需要多次引用，就是用外部样式。
			
 
				+      第三种，在html标签中添加style属性，属性值设置样式，属于内联样式。一般不推荐使用。
			
 
				+
			
 
				+      CSS的样式基本都是可以应用于全部标签。
			
 
				+    -->
			
 
				+    <!--背景样式-->
			
 
				+    <style>
			
 
				+        /*标签选择器---设置背景颜色*/
			
 
				+        div {
			
 
				+            width: 200px; /*宽度百分比，设置当前元素占用所在容器的百分比*/
			
 
				+            height: 400px;
			
 
				+            background-color: #0f0; /* #xxxxxx  #123*/
			
 
				+        }
			
 
				+
			
 
				+        /*class选择器---设置背景图片*/
			
 
				+        .myImg {
			
 
				+            background-image: url("./image/img01.jpg");
			
 
				+        }
			
 
				+
			
 
				+        /*id选择器-设置背景图片水平平铺*/
			
 
				+        /*id选择器-设置图片在背景中的位置*/
			
 
				+        #myImg {
			
 
				+            background-image: url("./image/img01.jpg");
			
 
				+            background-repeat: no-repeat;
			
 
				+            /*
			
 
				+                no-repeat:不平铺
			
 
				+                repeat-x: 延x轴平铺
			
 
				+                repeat-y: 延y轴平铺
			
 
				+            */
			
 
				+            background-position: left top;
			
 
				+        }
			
 
				+        /*
			
 
				+            简写属性：
			
 
				+            background:颜色、图片、平铺、位置
			
 
				+        */
			
 
				+        span{
			
 
				+            background: #00f url("./image/img01.jpg") no-repeat right top;
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body id="myImg">
			
 
				+<!--
			
 
				+块级标签：每个标签都会是独立的一行。
			
 
				+-->
			
 
				+<h1 class="myImg">zhangsan</h1>
			
 
				+<h1>zhangsan</h1>
			
 
				+<h1>zhangsan</h1>
			
 
				+<h1>zhangsan</h1>
			
 
				+<h1>zhangsan</h1>
			
 
				+<!--行级标签：每个标签都不是独立的一行，而是追加到前一个标签后面-->
			
 
				+<a href="http://www.baidu.com">百度</a>
			
 
				+<a href="http://www.baidu.com">百度</a>
			
 
				+<a href="http://www.baidu.com">百度</a>
			
 
				+<a href="http://www.baidu.com">百度</a>
			
 
				+<a href="http://www.baidu.com">百度</a>
			
 
				+
			
 
				+<!--div块标签-->
			
 
				+<div class="myImg">我是div</div>
			
 
				+<div class="myImg">我是div</div>
			
 
				+<div class="myImg">我是div</div>
			
 
				+
			
 
				+<!--span行标签-->
			
 
				+<span>我是span</span>
			
 
				+<span>我是span</span>
			
 
				+<span>我是span</span>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo02-border.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo02-border.html
@@ -0,0 +1,78 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>CSS边框样式</title>
			
 
				+    <!--边框样式属性-->
			
 
				+    <style>
			
 
				+        /*所有的h1标签中class的属性值是dotted的标签，会渲染当前选择器的样式*/
			
 
				+        h1.dotted {
			
 
				+            border-style: dotted;   /*边框样式：点线样式*/
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #00ff00;  /*边框颜色*/
			
 
				+
			
 
				+        }
			
 
				+        h1.dashed {
			
 
				+            border-style: dashed;   /*边框样式：虚线样式*/
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #0000ff;  /*边框颜色*/
			
 
				+        }
			
 
				+        h1.solid {
			
 
				+            border-style: solid;   /*边框样式：实线样式*/
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #ff0000;  /*边框颜色*/
			
 
				+        }
			
 
				+        h1.groove {
			
 
				+            border-style: groove;   /*边框样式：3D坡口样式*/
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #0f0f00;  /*边框颜色*/
			
 
				+        }
			
 
				+        h1.ridge {
			
 
				+            border-style: ridge;   /*边框样式：3D脊线样式*/
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #00ff00;  /*边框颜色*/
			
 
				+        }
			
 
				+        h1.solid-top {
			
 
				+            border-top-style: solid;   /*边框样式：实线样式*/
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #ff0000;  /*边框颜色*/
			
 
				+        }
			
 
				+        h1.solid-left {
			
 
				+            border-left-style: solid;   /*边框样式：实线样式*/
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #ff0000;  /*边框颜色*/
			
 
				+        }
			
 
				+        h1.solid-right {
			
 
				+            border-right-style: solid;   /*边框样式：实线样式*/
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #ff0000;  /*边框颜色*/
			
 
				+        }
			
 
				+        h1.solid-bottom {
			
 
				+            border-top-style: dotted;
			
 
				+            border-left-style: dashed;
			
 
				+            border-right-style: groove;
			
 
				+            border-bottom-style: solid;
			
 
				+            border-width: 5px;  /*边框宽度*/
			
 
				+            border-color: #ff0000;  /*边框颜色*/
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <a href="http://" class="dotted">百度</a>
			
 
				+    <h1 class="dotted">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="dashed">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="solid">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="groove">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="ridge">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="solid-top">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="solid-left">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="solid-right">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="solid-bottom">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+    <h1 class="">我是一个h1标签的内容，我有我自己的样式</h1>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo03-text.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo03-text.html
@@ -0,0 +1,103 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>CSS文本样式</title>
			
 
				+    <style>
			
 
				+        .text-color{
			
 
				+            color: #00ff00;
			
 
				+            background-color: red;/*设置背景颜色*/
			
 
				+        }
			
 
				+        .txt-center{
			
 
				+            text-align: center;
			
 
				+        }
			
 
				+        /*文本对齐*/
			
 
				+        .txt-align{
			
 
				+            text-align: right;  /**/
			
 
				+        }
			
 
				+        /*文本方向*/
			
 
				+        .txt-vertical{
			
 
				+            direction: rtl;
			
 
				+            vertical-align: middle;
			
 
				+        }
			
 
				+        /*文本装饰*/
			
 
				+        .txt-decoration{
			
 
				+            text-decoration: overline;  /*上划线*/
			
 
				+            text-decoration: line-through;  /*中划线*/
			
 
				+            text-decoration: underline;  /*下划线*/
			
 
				+        }
			
 
				+        /*文本转换*/
			
 
				+        .txt-transform{
			
 
				+            text-transform: uppercase;  /*转换为大写字母*/
			
 
				+            text-transform: lowercase;  /*转换为小写字母*/
			
 
				+            text-transform: capitalize;  /*保持不变*/
			
 
				+        }
			
 
				+        /*文本间距*/
			
 
				+        .txt-indent{
			
 
				+            text-indent: 50px;  /*文本缩进50px*/
			
 
				+            letter-spacing: 10px;   /*字母间距*/
			
 
				+            line-height: 2;  /*行高*/
			
 
				+            word-spacing: 30px; /*字间距 单词和单词之间的间距*/
			
 
				+        }
			
 
				+        /*文本阴影*/
			
 
				+        .txt-shadow{
			
 
				+            text-shadow: -2px -1px 2px red;   /*左 上 模糊 颜色设置文字阴影和颜色*/
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <p class="text-color">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="txt-align">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="text-color txt-right">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="txt-vertical">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="txt-decoration">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="txt-transform">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="txt-indent">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="txt-shadow">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+    <p class="">
			
 
				+        由北京微鲤科技有限公司开发的生活实用工具类APP，最初发布于Android、iOS及Windows
			
 
				+        Phone平台。部分用户反馈其功能冗余及广告干扰体验，但仍保持较高市场覆盖率。
			
 
				+    </p>
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo04-font.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo04-font.html
@@ -0,0 +1,54 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>CSS字体样式</title>
			
 
				+    <!--
			
 
				+        CSS有五种通用字体
			
 
				+
			
 
				+    -->
			
 
				+    <style>
			
 
				+        /*字体设置*/
			
 
				+        .font1{
			
 
				+            font-family: Serif; /*衬线字体*/
			
 
				+            font-style: normal; /*字体样式：正常显示*/
			
 
				+            font-size: 55px;    /*字体大小：55px*/
			
 
				+        }
			
 
				+        .font2{
			
 
				+            font-family: SansSerif; /*无衬线字体*/
			
 
				+            font-style: italic; /*字体样式：斜体*/
			
 
				+            font-size: 5vw;    /*字体大小：55vw vw:视口宽度，视口就是浏览器窗口的大小，
			
 
				+            1vw=视口宽度的1%，如果视口宽度50厘米，1vw就是0.5厘米*/
			
 
				+        }
			
 
				+        .font3{
			
 
				+            font-family: Monospaced; /*等宽字体*/
			
 
				+            font-style: oblique; /*字体样式：字体倾斜*/
			
 
				+        }
			
 
				+        .font4{
			
 
				+            font-family: Cursive; /*草书字体*/
			
 
				+            font-weight: normal; /*字体粗细：正常显示*/
			
 
				+        }
			
 
				+        .font5{
			
 
				+            font-family: Fantasy; /*幻想字体*/
			
 
				+            font-weight: bold; /*字体粗细：加粗*/
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <p class="font1">
			
 
				+        我是一段内容，Hello World! 123456。
			
 
				+    </p>
			
 
				+    <p class="font2">
			
 
				+        我是一段内容，Hello World! 123456。
			
 
				+    </p>
			
 
				+    <p class="font3">
			
 
				+        我是一段内容，Hello World! 123456。
			
 
				+    </p>
			
 
				+    <p class="font4">
			
 
				+        我是一段内容，Hello World! 123456。
			
 
				+    </p>
			
 
				+    <p class="font5">
			
 
				+        我是一段内容，Hello World! 123456。
			
 
				+    </p>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo05-link.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo05-link.html
@@ -0,0 +1,43 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>CSS链接样式</title>
			
 
				+    <style>
			
 
				+        /*设置a标签链接的状态样式*/
			
 
				+        /*
			
 
				+            a标签有四种状态：
			
 
				+                正常的，未被访问链接
			
 
				+                用户访问过的链接
			
 
				+                用户将鼠标悬停在链接上时
			
 
				+                链接被点击时的状态
			
 
				+        */
			
 
				+        /*正常的，未被访问链接*/
			
 
				+        a:link{
			
 
				+            color: #000;
			
 
				+            text-decoration: none;/*删除链接的下划线*/
			
 
				+            background-color: #d7cece;
			
 
				+        }
			
 
				+        /*用户访问过的链接*/
			
 
				+        a:visited{
			
 
				+            color: #0f0;
			
 
				+        }
			
 
				+        /*用户将鼠标悬停在链接上时*/
			
 
				+        a:hover{
			
 
				+            /*color: #f00;*/
			
 
				+            background-color: #b8b1b1;
			
 
				+        }
			
 
				+        /*链接被点击时的状态*/
			
 
				+        a:active{
			
 
				+            color: #00f;
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <a href="#" target="_blank">首页</a>
			
 
				+    <a href="#" target="_blank">用户管理</a>
			
 
				+    <a href="#" target="_blank">部门管理</a>
			
 
				+    <a href="#" target="_blank">账号管理</a>
			
 
				+    <a href="#" target="_blank">系统设置</a>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo06-boxModel.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo06-boxModel.html
@@ -0,0 +1,43 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>CSS盒子模型</title>
			
 
				+    <style>
			
 
				+        *{
			
 
				+            margin: 0;  /*设置外边距为0*/
			
 
				+            padding: 0;/*设置内边距为0*/
			
 
				+        }
			
 
				+        body {
			
 
				+            background-color: red;
			
 
				+        }
			
 
				+        div{
			
 
				+            width: 100%;
			
 
				+            height: 100%;
			
 
				+            background-color: #fff;
			
 
				+        }
			
 
				+        /*外边距：margin*/
			
 
				+        div{
			
 
				+            margin-top: 50px;       /*上外边距*/
			
 
				+            margin-left: 10px;      /*左外边距*/
			
 
				+            margin-right: 20px;     /*右外边距*/
			
 
				+            margin-bottom: 40px;    /*下外边距*/
			
 
				+            margin: 100px; /*元素的上下左右外边距都是100px*/
			
 
				+            margin: 50px 100px;     /*上下边距50 左右100*/
			
 
				+            margin: 10px 20px 30px 40px; /*左 上 右 下*/
			
 
				+        }
			
 
				+        div{
			
 
				+            padding-top: 50px;       /*上内边距*/
			
 
				+            padding-left: 10px;      /*左内边距*/
			
 
				+            padding-right: 20px;     /*右内边距*/
			
 
				+            padding-bottom: 40px;    /*下内边距*/
			
 
				+            padding: 100px; /*元素的上下左右内边距都是100px*/
			
 
				+            padding: 50px 100px;     /*上下边距50 左右100*/
			
 
				+            padding: 10px 20px 30px 40px; /*左 上 右 下*/
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <div>啊实打实大大</div>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo07-other.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo07-other.html
@@ -0,0 +1,92 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>CSS其他样式</title>
			
 
				+    <!---->
			
 
				+    <style>
			
 
				+        /*
			
 
				+            display属性，设置是否/如何显示元素
			
 
				+            每个HTML元素都有一个默认的display值，
			
 
				+            可能是block 块状元素，比如div h1 p
			
 
				+            可能是inline 行级元素 比如a input ....
			
 
				+        */
			
 
				+        h1 {
			
 
				+            display: inline;
			
 
				+        }
			
 
				+
			
 
				+        a {
			
 
				+            display: block;
			
 
				+        }
			
 
				+        p{
			
 
				+            color: #fff;
			
 
				+        }
			
 
				+        p.two {
			
 
				+            display: none; /*隐藏这个元素*/
			
 
				+        }
			
 
				+        /*
			
 
				+            position 定位样式
			
 
				+            用来规定元素定位方法的类型
			
 
				+            规定了应用于HTML元素的定位给方法的类型有5种：
			
 
				+            static  静态 静态定位的元素不会受到top bottom left right属性的影响
			
 
				+            relative 相对定位，会受到top bottom left right属性的影响
			
 
				+            fixed   相对于视口进行定位，即使滚动页面，也始终处在同一位置
			
 
				+            absolute   绝对定位 相对最近的定位祖先元素进行定位，
			
 
				+            sticky  根据用户的滚动位置进行定位 根据滚动位置在相对和固定之间进行切换，
			
 
				+            会先被相对定位，直到视口遇到了给定的偏移位置，然后再粘贴到这个位置。
			
 
				+        */
			
 
				+        div{
			
 
				+            border: solid 1px red;
			
 
				+            background-color: #00f600;
			
 
				+            position: sticky;
			
 
				+            height: 100px;
			
 
				+            left: 50px;
			
 
				+            top:0px;
			
 
				+            z-index:-1; /*设置Z轴方向的位置，元素重叠时哪个元素在前，哪个元素在后*/
			
 
				+        }
			
 
				+        img{
			
 
				+            height: 100px;
			
 
				+        }
			
 
				+        p{
			
 
				+            border-bottom: solid 1px red;
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<h1>一级标题</h1>
			
 
				+<a href="#" target="_blank">首页</a>
			
 
				+<a href="#" target="_blank">用户管理</a>
			
 
				+<a href="#" target="_blank">部门管理</a>
			
 
				+<a href="#" target="_blank">账号管理</a>
			
 
				+<a href="#" target="_blank">系统设置</a>
			
 
				+<p>
			
 
				+    111111111111111111111
			
 
				+</p>
			
 
				+<p class="two">
			
 
				+    222222222222222222222
			
 
				+</p>
			
 
				+<p>
			
 
				+    333333333333333333333
			
 
				+</p>
			
 
				+<p>
			
 
				+    444444444444444444444
			
 
				+</p>
			
 
				+<p>
			
 
				+    333333333333333333333
			
 
				+</p>
			
 
				+
			
 
				+<div>
			
 
				+    <h1>我是有粘性的！！！！！</h1>
			
 
				+</div>
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo08-overflow.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo08-overflow.html
@@ -0,0 +1,35 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>CSS溢出</title>
			
 
				+    <style>
			
 
				+        /*
			
 
				+        overflow属性 用来控制某些区域不能容纳的内容
			
 
				+        属性值：
			
 
				+            visible 默认的，溢出的时候没有裁剪，内容放在元素框外进行渲染。
			
 
				+            hidden 溢出就会被裁剪，其余内容不可见
			
 
				+            scroll 溢出就会被裁剪，同时添加滚动条来查看其余内容
			
 
				+            auto 和scroll类似，但是是在必要的时候添加滚动条
			
 
				+        overflow属性只有在指定了具体高度的时候，才有效。
			
 
				+        */
			
 
				+        div {
			
 
				+            width: 200px;
			
 
				+            height: 200px;
			
 
				+            border: solid 5px red;
			
 
				+            position: absolute;
			
 
				+            overflow: scroll;
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+<div>
			
 
				+    <p>
			
 
				+        123456789，123456789，123456789，123456789，
			
 
				+        123456789，123456789，123456789，123456789，
			
 
				+        123456789，123456789，123456789，123456789，
			
 
				+        123456789，123456789，123456789，123456789
			
 
				+    </p>
			
 
				+</div>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/demo09-float.html
+++ b/html&css&javaScriptProject/htmlCssDemo/demo09-float.html
@@ -0,0 +1,41 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>CSS浮动</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+<style>
			
 
				+    /*
			
 
				+        CSS float属性设置元素要怎么浮动
			
 
				+        CSS clear属性设置哪些元素可以在清除的元素旁边以及哪一测浮动。
			
 
				+        float主要是用来定位和格式化内容
			
 
				+    */
			
 
				+    div {
			
 
				+        width: 100px;
			
 
				+        height: 100px;
			
 
				+        border: solid 2px red;
			
 
				+    }
			
 
				+    .f1{
			
 
				+        background-color: red;
			
 
				+        float: left;
			
 
				+    }
			
 
				+    .f2{
			
 
				+        background-color: #00ff00;
			
 
				+        clear: none;
			
 
				+        float: left;
			
 
				+    }
			
 
				+    .f3{
			
 
				+        background-color: #0000ff;
			
 
				+    }
			
 
				+    .f4{
			
 
				+        background-color: #000;
			
 
				+        float: left;
			
 
				+    }
			
 
				+</style>
			
 
				+</body>
			
 
				+<div class="f1"><h1>1</h1></div>
			
 
				+<div class="f2"><h1>2</h1></div>
			
 
				+<div class="f3"><h1>3</h1></div>
			
 
				+<div class="f4"><h1>4</h1></div>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlCssDemo/image/img01.jpg
+++ b/html&css&javaScriptProject/htmlCssDemo/image/img01.jpg
--- a/html&css&javaScriptProject/htmlDemo/css/style.css
+++ b/html&css&javaScriptProject/htmlDemo/css/style.css
@@ -0,0 +1,6 @@
 
				+h2{
			
 
				+    background-color: aqua;
			
 
				+}
			
 
				+h1{
			
 
				+    background-color: aliceblue;
			
 
				+}
			
--- a/html&css&javaScriptProject/htmlDemo/cssDemo01.html
+++ b/html&css&javaScriptProject/htmlDemo/cssDemo01.html
@@ -0,0 +1,30 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+    <!--引入外部样式-->
			
 
				+    <link rel="stylesheet" href="css/style.css">
			
 
				+    <!--内部引入CSS，就是把css代码直接写在html文件的head标签里的style标签中-->
			
 
				+    <style>
			
 
				+        h1{
			
 
				+            background-color: yellow;
			
 
				+        }
			
 
				+        body{
			
 
				+            background-color: aquamarine;
			
 
				+        }
			
 
				+    </style>
			
 
				+</head>
			
 
				+<!--行内引入CSS样式-->
			
 
				+<body style="background-color: red">
			
 
				+    <h1>我是黄色的背景</h1>
			
 
				+    <h2>我是黄色的背景</h2>
			
 
				+    <h1>我是黄色的背景</h1>
			
 
				+    <h1>我是黄色的背景</h1>
			
 
				+    <h2>我是黄色的背景</h2>
			
 
				+    <h1>我是黄色的背景</h1>
			
 
				+    <h2>我是黄色的背景</h2>
			
 
				+    <h2>我是黄色的背景</h2>
			
 
				+    <h1>我是黄色的背景</h1>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlDemo/cssDemo02.html
+++ b/html&css&javaScriptProject/htmlDemo/cssDemo02.html
@@ -0,0 +1,74 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+    <style>
			
 
				+        /*
			
 
				+            CSS选择器分为基本选择器和扩展选择器
			
 
				+            CSS有三种基本选择器：
			
 
				+                标签选择器：
			
 
				+                    标签名{
			
 
				+                        属性名:属性值;
			
 
				+                    }
			
 
				+
			
 
				+        */
			
 
				+        h1 {
			
 
				+            color: red; /*设置颜色*/
			
 
				+            background-color: yellow; /*设置背景颜色*/
			
 
				+        }
			
 
				+
			
 
				+        /*
			
 
				+            类选择器
			
 
				+                .类名{
			
 
				+
			
 
				+                }
			
 
				+        */
			
 
				+        .myC{
			
 
				+            background-color: aqua;
			
 
				+        }
			
 
				+        /*
			
 
				+            id选择器
			
 
				+                #id值{
			
 
				+
			
 
				+                }
			
 
				+        */
			
 
				+        #myh1{
			
 
				+            /*color: rgb(0, 0, 255);*/
			
 
				+            color: #0000ff;
			
 
				+        }
			
 
				+        /*
			
 
				+            这是十进制的色值
			
 
				+            RGB(0,0,0)
			
 
				+            第1个值代表红色
			
 
				+            第2个值代表绿色
			
 
				+            第3个值代表蓝色
			
 
				+            取值范围最小是0，最大是255
			
 
				+            把RGB色值都转换为十六进制
			
 
				+            就得到了十六进制色值
			
 
				+            #xxxxxx
			
 
				+            前两个xx代表红色
			
 
				+            中间两个xx代表绿色
			
 
				+            最后连个xx代表蓝色
			
 
				+        */
			
 
				+
			
 
				+        body{
			
 
				+            /*background-image: url("./img/829714124.jpeg");*/
			
 
				+            /*background-repeat: no-repeat;   !*设置水平或垂直方向平铺*!*/
			
 
				+            background: url("img/829714124.jpeg") repeat-x;
			
 
				+        }
			
 
				+
			
 
				+    </style>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <h1 id="myh1">Hello</h1>
			
 
				+    <h1>Hello</h1>
			
 
				+    <h1 class="myC">Hello</h1>
			
 
				+    <h1>Hello</h1>
			
 
				+    <h1 class="myC">Hello</h1>
			
 
				+    <h1>Hello</h1>
			
 
				+    <p class="myC">
			
 
				+        alskdjalskjdlakdslakkhdlajkshdjasdhkaj
			
 
				+    </p>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlDemo/demo01.html
+++ b/html&css&javaScriptProject/htmlDemo/demo01.html
@@ -0,0 +1,40 @@
 
				+<!DOCTYPE html>         <!--这就是一个标签-->
			
 
				+<!--  这是注释，多行注释或者单行注释都用它  -->
			
 
				+<html lang="zh-CN">  <!--lang指的是语言，en表示English ，中国大陆是：zh-CN   -->
			
 
				+    <!-- 这是一组标签，由开始标签和结束标签组成，
			
 
				+    结束标签除了比开始标签的字母前多一个/之外，其他的和开始标签完全一样
			
 
				+    -->
			
 
				+    <!--head 是网页的头部，一般在这编写对网页整体的一些配置-->
			
 
				+    <head>
			
 
				+        <meta charset="UTF-8" />    <!--这是一个非闭合标签-->
			
 
				+        <title>我是网页的标题</title>  <!--这是网页的标签页的标题-->
			
 
				+    </head>
			
 
				+    <!--body 是网页的身体，网页的主体，里面编写是网页的主体内容-->
			
 
				+    <body>
			
 
				+        <!--网页内容的题目标题  , html中由6种标签，从大到小分别是h1~h6-->
			
 
				+        <h1>我是1级标题</h1>
			
 
				+        <h2>我是2级标题</h2>
			
 
				+        <h3>我是3级标题</h3>
			
 
				+        <h4>我是4级标题</h4>
			
 
				+        <h5>我是5级标题</h5>
			
 
				+        <h6>我是6级标题</h6>
			
 
				+
			
 
				+        <!--段落标签  p标签  一对p标签里面就是一个段落   -->
			
 
				+        <p>我是第1段</p>
			
 
				+        <p>我是第2段</p><p>我是第3段</p>
			
 
				+        <!--
			
 
				+            b标签  字体加粗
			
 
				+            br标签 换行
			
 
				+            center标签 文本居中 但是现在不建议使用，已经淘汰了
			
 
				+            hr标签 分割线
			
 
				+        -->
			
 
				+        <hr>
			
 
				+        <center>
			
 
				+            <p><b>超文本标记语言（英语：HyperText Markup Language，简称：HTML）</b>是一种用于创建网页的标准标记语言。 <br/>
			
 
				+                您可以使用 HTML 来建立自己的 WEB 站点，HTML 运行在浏览器上，由浏览器来解析。<br/>
			
 
				+                在本教程中，您将学习如何使用 HTML 来创建站点。 HTML 很容易学习！相信您能很快学会它</p>
			
 
				+        </center>
			
 
				+
			
 
				+
			
 
				+    </body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlDemo/demo02.html
+++ b/html&css&javaScriptProject/htmlDemo/demo02.html
@@ -0,0 +1,29 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <!--
			
 
				+        图片标签
			
 
				+            <img src="" width="" height="">标签，定义图片
			
 
				+            src属性：规定显示图片的URL(同一资源定位符)
			
 
				+            width="" 定义图片的宽度
			
 
				+            height="" 定义图片的高度
			
 
				+            alt=""  如果图片加载失败，则显示alt里面的内容
			
 
				+        音频标签
			
 
				+        <audio src="xxxx.mp3" controls> 音频标签
			
 
				+        视频标签
			
 
				+        <video src="xxxxx"  controls>
			
 
				+
			
 
				+
			
 
				+    -->
			
 
				+    <img src="https://www.cikeee.cc/uploads/movimg/523/106d/681024153557049.jpg" alt="图片加载失败">
			
 
				+    <img src="https://img14.360buyimg.com/n1/s720x720_jfs/t1/329520/4/11807/97257/68c19e49F14842b56/664a377344db6eda.jpg" width="100px">   <!-- ./属于相对路径-->
			
 
				+
			
 
				+    <!--px 像素-->
			
 
				+    <!--    <img src="D:/Code/javaProjects/htmlProject/img/829714124.jpeg" alt="">-->
			
 
				+    <video src="https://cdn.pixabay.com/video/2024/05/18/212404_large.mp4" controls width="500px"></video>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlDemo/demo03.html
+++ b/html&css&javaScriptProject/htmlDemo/demo03.html
@@ -0,0 +1,24 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <!--
			
 
				+        超链接标签
			
 
				+            <a href="" target="">    定义一个超链接，用来链接到另一个资源
			
 
				+            href="" 指定访问资源的url
			
 
				+            target="" 指定打开资源的方式
			
 
				+                _self ：默认值是在当前的页面打开
			
 
				+                _blank ：在新的标签页打开
			
 
				+    -->
			
 
				+    <a href="http://www.baidu.com" target="_blank"><h1>百度一下</h1></a>
			
 
				+    <h1><a href="http://www.taobao.com" target="_blank">淘宝</a></h1>
			
 
				+    <a href="http://www.JD.com" target="_blank">
			
 
				+        <img src="img/829714124.jpeg" alt="">
			
 
				+    </a>
			
 
				+
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlDemo/demo04.html
+++ b/html&css&javaScriptProject/htmlDemo/demo04.html
@@ -0,0 +1,33 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>Title</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <!--
			
 
				+        列表标签
			
 
				+            无序列表
			
 
				+                <ul>标签
			
 
				+            有序列表
			
 
				+                <ol> 标签
			
 
				+            列表项  <li>
			
 
				+    -->
			
 
				+    <!--注释的快捷方式： Ctrl + /   Ctrl + Shift + /-->
			
 
				+    <!--无序列表-->
			
 
				+    <ul>
			
 
				+        <li><h1>咖啡</h1></li>
			
 
				+        <li>牛奶</li>
			
 
				+        <li>茶叶</li>
			
 
				+    </ul>
			
 
				+    <!--有序列表-->
			
 
				+    <ol>
			
 
				+        <li>花生</li>
			
 
				+        <li>瓜子</li>
			
 
				+        <li>八宝粥</li>
			
 
				+    </ol>
			
 
				+
			
 
				+
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlDemo/demo05.html
+++ b/html&css&javaScriptProject/htmlDemo/demo05.html
@@ -0,0 +1,46 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="en">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>表格</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <!--
			
 
				+        表格标签
			
 
				+            <table border="" width=""> 定义表格
			
 
				+                border: 定义表格的边框的宽度
			
 
				+                width: 定义表格的宽度
			
 
				+                cellspacing 定义表格里各个单元格之间的空白
			
 
				+            <tr> 定义表格里的行标签
			
 
				+            <td> 定义表格里的列标签
			
 
				+            <th> 定义表格的标题标签
			
 
				+    -->
			
 
				+    <table width="500px" border="1px" cellspacing="1px">
			
 
				+        <tr>
			
 
				+            <th>标题</th>
			
 
				+            <th>标题</th>
			
 
				+            <th>标题</th>
			
 
				+            <th>标题</th>
			
 
				+        </tr>
			
 
				+        <tr align="center">
			
 
				+            <td>第1行-第1列</td>
			
 
				+            <td>第1行-第2列</td>
			
 
				+            <td>第1行-第3列</td>
			
 
				+            <td>第1行-第4列</td>
			
 
				+        </tr>
			
 
				+        <tr align="right">
			
 
				+            <td>第2行-第1列</td>
			
 
				+            <td align="center">第2行-第2列</td>
			
 
				+            <td>第2行-第3列</td>
			
 
				+            <td>第2行-第4列</td>
			
 
				+        </tr>
			
 
				+        <tr align="left">
			
 
				+            <td>第3行-第1列</td>
			
 
				+            <td>第3行-第2列</td>
			
 
				+            <td>第3行-第3列</td>
			
 
				+            <td>第3行-第4列</td>
			
 
				+        </tr>
			
 
				+
			
 
				+    </table>
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlDemo/demo06.html
+++ b/html&css&javaScriptProject/htmlDemo/demo06.html
@@ -0,0 +1,68 @@
 
				+<!DOCTYPE html>
			
 
				+<html lang="zh-CN">
			
 
				+<head>
			
 
				+    <meta charset="UTF-8">
			
 
				+    <title>表单标签</title>
			
 
				+</head>
			
 
				+<body>
			
 
				+    <!--
			
 
				+        表单标签，就是注册、登录、搜索、查询等等需要输入的，选择的各种标签
			
 
				+        表单的作用，就是采集用户输入 的数据，然后将数据发送到服务端(后端)，
			
 
				+        服务端会对数据库进行操作。
			
 
				+
			
 
				+        <form>  定义表单
			
 
				+           action="" 将表单的信息要提交到哪个位置
			
 
				+           规定当提交表单的时候，向什么位置发送表单数据，这个属性值是URL
			
 
				+           method="" 规定用来发送表单数据的方式
			
 
				+                method属性最基础的两种值：
			
 
				+                    get  是将表单数据拼接到URL的后面，直接发送到服务端，用来发送敏感数据的时候不建议使用。
			
 
				+                        拼接到URL后面的内容长度是由限制的，最大不超过4KB
			
 
				+                    post 是将表单的数据放入http请求的请求体中，参数没有大小限制。
			
 
				+        表单项：
			
 
				+            <input> 标签，通过type属性可以控制输入的形式
			
 
				+                type="text"  定义文本输入框
			
 
				+                type="username"  定义用户名输入框
			
 
				+                type="password" 定义密码输入框
			
 
				+                type="radio"  定义单选按钮输入框
			
 
				+                type="checkbox"  定义复选框输入框
			
 
				+                type="date"  定义日期输入框
			
 
				+                type="datetime-local"  定义日期时间输入框
			
 
				+                type="reset" 重置
			
 
				+                type="submit" 提交
			
 
				+
			
 
				+          下拉列表  <select>
			
 
				+            下拉列表的列表项  <option>
			
 
				+            文本框，可以输入多行内容<textarea>
			
 
				+
			
 
				+    -->
			
 
				+    <form action="/user/register" method="post">
			
 
				+        真实姓名：<input type="text" name="realName" id="realName"><br/>
			
 
				+        用户名：<input type="username" name="username" id="username"><br/>
			
 
				+        密码：<input type="password" name="password" id="password"> <br/>
			
 
				+        性别：<input type="radio" name="sex" id="man" value="man"> 男
			
 
				+        <input type="radio" name="sex" id="woman" value="man"> 女<br/>
			
 
				+        爱好：
			
 
				+        <input type="checkbox" name="hobby" id="c1" value="c1"> 抽烟
			
 
				+        <input type="checkbox" name="hobby" id="h1" value="h1"> 喝酒
			
 
				+        <input type="checkbox" name="hobby" id="t1" value="t1"> 烫头<br/>
			
 
				+        生日：<input type="datetime-local" name="birthday" id="birthday"><br/>
			
 
				+        <input type="reset" value="重置">
			
 
				+        <input type="submit" value="注册">
			
 
				+        <input type="button" value="普通按钮"><br/>
			
 
				+        <!--下拉列表-->
			
 
				+        <select name="hobby1" id="hobby1">
			
 
				+            <option value="c1">抽烟</option>
			
 
				+            <option value="c2">抽烟1</option>
			
 
				+            <option value="c3">抽烟1</option>
			
 
				+        </select><br/>
			
 
				+        个人评价<br/>
			
 
				+        <textarea cols="200" rows="5" name="desc"></textarea>
			
 
				+
			
 
				+
			
 
				+    </form>
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+</body>
			
 
				+</html>
			
--- a/html&css&javaScriptProject/htmlDemo/img/829714124.jpeg
+++ b/html&css&javaScriptProject/htmlDemo/img/829714124.jpeg
--- a/html&css&javaScriptProject/htmlDemo/练习题.txt
+++ b/html&css&javaScriptProject/htmlDemo/练习题.txt
@@ -0,0 +1,13 @@
 
				+1、请创建一个简单的网页，包含一个一级标题 "我的爱好"，一个段落介绍你的三个爱好（其中一个爱好用粗体显示），然后用水平线分隔，最后添加一张与你爱好相关的图片（图片需要有替代文本）。
			
 
				+2、制作一个介绍你最喜欢的电影的网页：包含二级标题 "我最爱的电影"，一个段落描述该电影（其中电影名称用粗体），插入该电影的海报图片，再用水平线分隔，最后添加一个视频（可以使用示例视频链接）展示电影片段。
			
 
				+3、创建一个网页，包含三级标题 "我的学习计划"，两个段落分别描述你上午和下午的学习内容，用水平线分隔不同时间段，最后添加一个链接到你常用的学习网站。
			
 
				+4、制作一个简单的网页简历：使用 h1 作为 "个人简历" 标题，h2 作为 "基本信息" 和 "技能" 小标题，用段落标签介绍自己，其中重要信息用粗体，添加一张个人照片，并用水平线分隔不同部分。
			
 
				+5、创建一个介绍你家乡的网页：包含 h1 标题 "我的家乡"，几个段落介绍家乡的风景、美食等（关键名称用粗体），插入至少一张家乡风景图片，一个介绍家乡的视频，并用水平线分隔不同内容板块，最后添加一个链接到家乡的官方旅游网站。
			
 
				+
			
 
				+
			
 
				+
			
 
				+1. 制作一个"我的书架"网页：用h2标题"我的书架"，两个段落分别介绍你最近读过的两本书（每本书的书名用粗体），用水平线分隔两本书的介绍，为每本书添加一张封面图片（需有替代文本），最后添加一个链接到你购买书籍的网站。
			
 
				+
			
 
				+2. 创建一个"季节介绍"网页：用h1标题"我最喜欢的季节"，用段落描述你喜欢这个季节的原因（其中季节名称用粗体），插入一张能代表该季节的图片，用水平线分隔后，添加一个展示该季节景色的视频，最后用一个段落补充说明视频内容。
			
 
				+
			
 
				+3. 制作一个简单的"每日记录"网页：用h3标题"今日记录"，三个段落分别记录早上、中午和晚上发生的事情，每个段落之间用水平线分隔，为其中一件有意义的事情添加相关图片，最后添加一个链接到你的日记本（可以用示例链接）。
			
--- a/javaSE/javaSE.iml
+++ b/javaSE/javaSE.iml
@@ -0,0 +1,21 @@
 
				+<?xml version="1.0" encoding="UTF-8"?>
			
 
				+<module type="JAVA_MODULE" version="4">
			
 
				+  <component name="NewModuleRootManager" inherit-compiler-output="true">
			
 
				+    <exclude-output />
			
 
				+    <content url="file://$MODULE_DIR$">
			
 
				+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
			
 
				+    </content>
			
 
				+    <orderEntry type="inheritedJdk" />
			
 
				+    <orderEntry type="sourceFolder" forTests="false" />
			
 
				+    <orderEntry type="module-library" exported="">
			
 
				+      <library>
			
 
				+        <CLASSES>
			
 
				+          <root url="file://$MODULE_DIR$/lib" />
			
 
				+        </CLASSES>
			
 
				+        <JAVADOC />
			
 
				+        <SOURCES />
			
 
				+        <jarDirectory url="file://$MODULE_DIR$/lib" recursive="false" />
			
 
				+      </library>
			
 
				+    </orderEntry>
			
 
				+  </component>
			
 
				+</module>
			
--- a/javaSE/myfile.properties
+++ b/javaSE/myfile.properties
@@ -0,0 +1,7 @@
 
				+#\u8FD9\u662F\u4E00\u4E2A\u975E\u5E38\u6709\u610F\u601D\u7684\u4ECB\u7ECD
			
 
				+#Mon Jul 28 14:06:11 CST 2025
			
 
				+age=25
			
 
				+password=123456
			
 
				+name=张三
			
 
				+sex=男
			
 
				+username=zhangsan
			
--- a/javaSE/out/production/javaSE/J20250714/API文档.txt
+++ b/javaSE/out/production/javaSE/J20250714/API文档.txt
@@ -0,0 +1,6 @@
 
				+API(Application Programing Interface) 应用程序编程接口
			
 
				+JDK1.8-API，就是一个API文档就是一个使用说明书
			
 
				+
			
 
				+Java的API
			
 
				+就是Java提供的各种功能的Java类，类的底层被封装起来了。
			
 
				+不用关心是怎么实现的。会用就可以了。
			
--- a/javaSE/out/production/javaSE/J20250714/String类常用方法.txt
+++ b/javaSE/out/production/javaSE/J20250714/String类常用方法.txt
@@ -0,0 +1,7 @@
 
				+作业1：挨个使用String的以下方法：
			
 
				+String类常用方法，
			
 
				+1、charAt(int index) 返回 char指定索引处的值。
			
 
				+2、toCharArray()  返回一个字符数组
			
 
				+3、subString(int beginIndex, int endIndex)
			
 
				+从beginIndex开始到endIndex结束，返回一个字符串，该字符串是此字符串的子字符串。
			
 
				+4、split(String regex)将这个字符串拆分为指定的字符串。
			
--- a/javaSE/out/production/javaSE/J20250714/封装思想.txt
+++ b/javaSE/out/production/javaSE/J20250714/封装思想.txt
@@ -0,0 +1,25 @@
 
				+1、什么是封装？
			
 
				+面向对象的语言有三大特征：封装、继承、多态
			
 
				+面向对象思想的编程语言，本身的目的就是对客观事物模拟。
			
 
				+外界是无法直接操作内部细节。
			
 
				+封装就是把自身的细节隐藏起来，暴露出可以被使用的接口。
			
 
				+封装原则：就是把类的信息隐藏在内部。不允许外部成员直接访问。
			
 
				+但是可以通过类提供的方法进行访问。
			
 
				+封装的好处：
			
 
				+可以通过方法来控制成员变量的操作，提高代码的安全性
			
 
				+把代码使用方法封装。提高代码的复用性。
			
 
				+
			
 
				+
			
 
				+封装的具体使用：
			
 
				+类中成员(类中的属性和方法)的权限修饰符：
			
 
				+分别是四种访问权限修饰符：
			
 
				+private：本类中可以访问
			
 
				+default：本类中可以访问，同一包中可以访问，不允许跨包访问，不用任何修饰符就是default
			
 
				+protected：本类中可以访问，同一包中可以访问，不允许正常的跨包访问，
			
 
				+但是允许跨包继承，非同包的子类是可以继承的。
			
 
				+public: 任意位置都可以访问的
			
 
				+
			
 
				+如果是修饰类本身，那么访问权限修饰符就只有两种：
			
 
				+public：任意位置都可以访问的
			
 
				+default：不加任何修饰的，默认的，同一包中可以访问，不允许跨包访问
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250714/构造方法.txt
+++ b/javaSE/out/production/javaSE/J20250714/构造方法.txt
@@ -0,0 +1,66 @@
 
				+构造方法：
			
 
				+其实就是构造Java对象的时候使用的方法。
			
 
				+也就是我们创建一个对象的时候需要调用的方法就是构造方法。
			
 
				+
			
 
				+格式：
			
 
				+    1、构造方法的方法名和类名完全一致，单词大小写全相同。
			
 
				+    2、构造方法不需要定义返回值类型，甚至连void都不需要
			
 
				+    (因为构造方法的返回值类型早就确定了，就是这个构造方法所属的类的类型)
			
 
				+    3、没有具体的返回值，不能使用return
			
 
				+
			
 
				+什么时候执行？
			
 
				+    构造方法，当创建对象的时候就会被调用，就会执行，每当创建一次对象，就会执行一次构造方法。
			
 
				+    不能手动调用构造方法
			
 
				+
			
 
				+注意：
			
 
				+    如果我们没有编写构造方法，那么系统会提供一个默认的构造方法。
			
 
				+    如果我们编写了构造方法，那么系统就不会提供了。
			
 
				+
			
 
				+
			
 
				+        //构造方法
			
 
				+        //  创建一个学生对象
			
 
				+        public Student(){   //无参构造方法
			
 
				+            System.out.println("我是一个学生对象");
			
 
				+        }
			
 
				+        //有参构造方法
			
 
				+        public Student(String id,String name,int age){
			
 
				+            this.id=id;
			
 
				+            this.name=name;
			
 
				+            this.age=age;
			
 
				+        }
			
 
				+
			
 
				+
			
 
				+建议：
			
 
				+    我们无论是否使用构造方法，都自己编写一个无参的构造方法一个有参的构造方法。
			
 
				+
			
 
				+
			
 
				+一个完整的实体类(映射某一类事物的类)一般都要包含以下内容：
			
 
				+    1、类的成员属性
			
 
				+    2、成员属性的set方法和get方法
			
 
				+    3、无参的构造方法、有参的构造方法
			
 
				+
			
 
				+
			
 
				+案例1：
			
 
				+    需求：已知用户名和密码，编写程序实现模拟用户登录。登录后给出相应提示。
			
 
				+    步骤：
			
 
				+        1、已知用户名和密码，定义两个字符串。
			
 
				+        2、键盘输入要登录的用户名和密码，使用Scanner实现
			
 
				+        Scanner sc=new Scanner(System.in);
			
 
				+        3、用键盘输入的用户名、密码和已知的用户名、密码进行比较，给出相应提示
			
 
				+        sc.next();//获取键盘输入的字符串
			
 
				+        4、字符串内容比较，使用equals进行比较。
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+案例1：
			
 
				+    需求：已知用户名和密码，编写程序实现模拟用户登录。总共给3次机会，登录后给出相应提示。
			
 
				+    步骤：
			
 
				+        1、已知用户名和密码，定义两个字符串。
			
 
				+        2、键盘输入要登录的用户名和密码，使用Scanner实现
			
 
				+        3、用键盘输入的用户名、密码和已知的用户名、密码进行比较，给出相应提示
			
 
				+        4、字符串内容比较，使用equals进行比较。
			
 
				+        5、使用循环实现多次机会，次数明确，for循环，登录成功，就用break跳出循环。
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250715/StringBuilder可变字符串.txt
+++ b/javaSE/out/production/javaSE/J20250715/StringBuilder可变字符串.txt
@@ -0,0 +1,35 @@
 
				+StringBuilder可变字符串
			
 
				+StringBuilder是一种可变长度的字符串类，可以把它看成一个容器，可变就是StringBuilder对象的内容是可以变化的。
			
 
				+StringBuilder和String的区别：
			
 
				+1、StringBuilder内容可变
			
 
				+2、String内容不可变
			
 
				+
			
 
				+StringBuilder的构造方法：
			
 
				+    StringBuilder() 构造一个没有字符的StringBuilder对象，初始容量为16个字符。
			
 
				+    StringBuilder(String str) 构造一个初始化为指定字符串内容的StringBuilder对象。
			
 
				+
			
 
				+StringBuilder的常用方法：
			
 
				+    append(任意类型) 将参数的字符串表示附加到StringBuilder字符串序列中。
			
 
				+    reverse() 字符串反转。
			
 
				+
			
 
				+StringBuilder和String之间进行转换：
			
 
				+    StringBuilder-》String   ： toString()方法就可以实现转换
			
 
				+    String-》StringBuilder   ：通过构造方法StringBuilder(String str) 就可以实现
			
 
				+
			
 
				+
			
 
				+
			
 
				+StringBuilder实验案例：
			
 
				+需求：
			
 
				+    定义一个方法，把int数组种的数据，按照指定的格式拼接成一个字符串返回，调用这个方法
			
 
				+    并且在控制台输入结果，比如数组：int[] arr={1,2,3}; 输出的结果为："[1,2,3]"
			
 
				+实现步骤：
			
 
				+    1、定义一个int类型数组，用静态初始化方式进行数组元素的初始化
			
 
				+    2、定义一个方法，用来把数组种的数据按照格式进行拼接，拼接为一个字符串返回
			
 
				+        方法的返回值类型String, 参数列表是int[] arr；
			
 
				+    3、在方法中实验StringBuilder按照要求进行拼接，并且把结果转化为String返回。
			
 
				+    4、调用方法，用一个变量接收结果
			
 
				+    5、输出结果
			
 
				+    public String arrayToString(int[] arr){
			
 
				+
			
 
				+    }
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250715/String常用方法.txt
+++ b/javaSE/out/production/javaSE/J20250715/String常用方法.txt
@@ -0,0 +1,11 @@
 
				+equals()方法：比较两个字符串是否内容一致，严格区分大小写
			
 
				+length()方法：返回字符串的长度
			
 
				+equalsIgnoreCase() ：比较两个字符串是否一致，不区分大小写
			
 
				+charAt():返回指定索引位置的字符
			
 
				+toCharArray():返回一个字符数组
			
 
				+substring(beginIndex,endIndex):从开始位置到结束位置进行截取字符串，返回截取后的字符串。
			
 
				+比如字符串：abcdef  substring(2,5)  得到的结果为：cde
			
 
				+substring(beginIndex):从索引值位置截取到结尾
			
 
				+split(regex):根据传入的字符串(也可以是正则表达式)进行切割，返回分隔后的字符串数组
			
 
				+replace(CharSequence target, CharSequence replacement)  将字符串中所有的target都换成replacement
			
 
				+比如字符串：hello world replace("l", "z") 得到结果：hezzo worzd
			
--- a/javaSE/out/production/javaSE/J20250715/_static/static修饰符静态的.txt
+++ b/javaSE/out/production/javaSE/J20250715/_static/static修饰符静态的.txt
@@ -0,0 +1,14 @@
 
				+static 是一种修饰符，可以修饰属性或方法
			
 
				+也可以叫static关键字。含义就是静态的意思。
			
 
				+
			
 
				+被static修饰的特点：
			
 
				+    1、如果static修饰某个属性变量，那么这个变量会被类的所有对象共享
			
 
				+    2、如果static修饰某个属性变量，那么这个变量会随着类的加载而加载，优于对象先加载。
			
 
				+    3、因为对象是需要等类加载完毕后，才创建。
			
 
				+    4、如果static修饰某个属性变量，那么这个变量可以通过类名直接调用。不需要对象调用。
			
 
				+
			
 
				+注意：
			
 
				+    static可以修饰变量，也可以修饰方法。不论修饰哪个，该成员都是属于类的。
			
 
				+    static修饰的方法，称为静态方法，静态方法只能访问静态的成员变量或成员方法。
			
 
				+    没有被static修饰的方法，称为非静态方法，非静态方法可以访问静态成员变量或成员方法，也可以访问非静态的。
			
 
				+    静态方法中是没有this关键字。
			
--- a/javaSE/out/production/javaSE/J20250715/extend/继承.txt
+++ b/javaSE/out/production/javaSE/J20250715/extend/继承.txt
@@ -0,0 +1,36 @@
 
				+面向对象的三大特征：
			
 
				+封装
			
 
				+继承
			
 
				+多态
			
 
				+
			
 
				+继承：
			
 
				+可以让子类具有父类的特征(属性和方法)，还可以在子类中重新定义，
			
 
				+甚至追加属性和方法
			
 
				+
			
 
				+
			
 
				+继承的格式：
			
 
				+    继承的关键字：extends
			
 
				+    格式：
			
 
				+        class 子类 extends 父类{
			
 
				+        }
			
 
				+    比如：
			
 
				+        class Dog extends Animal{
			
 
				+
			
 
				+        }
			
 
				+继承的好处：
			
 
				+    1、提高代码的复用性
			
 
				+    2、提高代码的可维护性
			
 
				+继承的弊端：
			
 
				+    继承让类和类之间产生了关系，增加了【耦合性】
			
 
				+    以后我们会用很多的时间和手段和技术，想办法解耦
			
 
				+    当父类发生了变化，子类也不得不跟着进行变化。削弱了子类的独立性。
			
 
				+
			
 
				+继承是一种 is...a的关系   是...一个    子类是一种父类
			
 
				+    [马]是一个[动物]
			
 
				+    [老师]是一个[动物]
			
 
				+    [人]是一个[动物]
			
 
				+    [老师]是一个[人]
			
 
				+
			
 
				+注意：
			
 
				+    Java中只能够单继承，也就是一个子类只能有一个直接父类。
			
 
				+    Java支持多重继承，也就是A继承B，B继承C，C继承D.....
			
--- a/javaSE/out/production/javaSE/J20250715/为什么输出对象打印的是地址.txt
+++ b/javaSE/out/production/javaSE/J20250715/为什么输出对象打印的是地址.txt
@@ -0,0 +1,7 @@
 
				+为什么我们自定义的类创建的对象，输出的这个对象的时候，在控制台打印的是对象的地址？
			
 
				+1、Java中规定任意类的直接父类或间接父类都是Object类。
			
 
				+2、Object类里面有一个toString()方法，这个方法就是返回当前对象所属类型和地址值。
			
 
				+格式：
			
 
				+    包名.类名@地址值
			
 
				+    J20250715.studentManager.Student@140e19d
			
 
				+3、当我们调用输出某个对象的时候，其实默认是调用这个类的toString()方法，如果它没有，就调用父类的。
			
--- a/javaSE/out/production/javaSE/J20250716/demo03_abstract/抽象类和抽象方法.txt
+++ b/javaSE/out/production/javaSE/J20250716/demo03_abstract/抽象类和抽象方法.txt
@@ -0,0 +1,27 @@
 
				+抽象类和抽象方法：
			
 
				+当我们在做子类共性特征功能抽取的时候，有些方法在父类中是没有具体功能体现的。
			
 
				+这时候就需要抽象类了。
			
 
				+Java中，如果一个方法，没有方法体，就应该被定义为抽象方法。
			
 
				+如果类中有了抽象方法，那么这个类就必须定义为抽象类
			
 
				+抽象类和抽象方法必须使用abstract关键字进行修饰：
			
 
				+抽象类：
			
 
				+public abstract class 类名{
			
 
				+    抽象方法：
			
 
				+    public abstract void 回家();
			
 
				+}
			
 
				+特点：
			
 
				+    1、抽象方法必须存在于抽象类中，但是抽象类不只有抽象方法，还有具体方法。
			
 
				+    2、抽象类是不能实例化，也就是不能创建对象的。
			
 
				+    3、抽象方法存在的唯一意义，就是被子类重写。
			
 
				+    4、抽象类的子类，要么重写父类的抽象方法，要么子类也必须是抽象类。
			
 
				+
			
 
				+案例需求：
			
 
				+    定义猫类(Cat)和狗类(Dog)
			
 
				+    猫的成员方法：eat(){猫吃鱼}  drink(){喝水...}
			
 
				+    狗的成员方法：eat(){狗吃肉}  drink(){喝水...}
			
 
				+实现步骤：
			
 
				+    1、猫类和狗类存在共性特征，应该向上抽取出一个动物类Animal
			
 
				+    2、父类Animal中不能把eat方法具体描述清楚，所以定义成抽象方法。
			
 
				+    3、抽象方法需要存活在抽象类中，那么就要将Animal定义为抽象类。
			
 
				+    4、让Cat和Dog分别继承Animal，并且抽象eat()方法
			
 
				+    5、编写测试类，创建Cat和Dog对象，分别调用eat()和drink()方法进行测试。
			
--- a/javaSE/out/production/javaSE/J20250716/demo03_abstract/设计模式.txt
+++ b/javaSE/out/production/javaSE/J20250716/demo03_abstract/设计模式.txt
@@ -0,0 +1,19 @@
 
				+设计模式
			
 
				+设计模式是一套反复被使用，多数人知道，经过分类的，代码设计经验的总结。
			
 
				+使用设计模式，可以让代码更容易被他人理解，保证代码的可靠性，程序的重用性。
			
 
				+比较常说的：Java的23种设计模式 其实不止23种。
			
 
				+先说一种：
			
 
				+-[模板设计模式]
			
 
				+把抽象类整体看成一种模板，模板种不能决定的东西都定义为抽象方法。
			
 
				+让使用模板的类(继承抽象类的类)，去重写抽象方法，自己实现需求。
			
 
				+模板设计模式的优势：
			
 
				+    模板已经定义了通用的结构，使用的人只需要关心自己要实现的功能就可以了。
			
 
				+
			
 
				+abstract class 作文模板类{
			
 
				+    public void write(){
			
 
				+        System.out.println("《我的爸爸》");
			
 
				+        body();
			
 
				+        System.out.println("啊~这就是我的爸爸！");
			
 
				+    }
			
 
				+    public abstract void body();
			
 
				+}
			
--- a/javaSE/out/production/javaSE/J20250716/demo04_final/final.txt
+++ b/javaSE/out/production/javaSE/J20250716/demo04_final/final.txt
@@ -0,0 +1,8 @@
 
				+final也是一个关键字，可以修饰类、成员变量、成员方法
			
 
				+final代码最终的的意思，修饰类、成员变量、成员方法。
			
 
				+final修饰类、方法、变量的效果：
			
 
				+    final修饰类后，这个类就不能被继承，也就是不能有子类。
			
 
				+    final修饰方法，这个方法不能被重写。
			
 
				+    final修饰变量，这个变量是一个常量，不能再次赋值。不能改值。
			
 
				+    Java中对常量的定义是：
			
 
				+    在定义常量的时候，必须要初始化赋值，并且不能修改。
			
--- a/javaSE/out/production/javaSE/J20250716/demo05_codeblocks/代码块.txt
+++ b/javaSE/out/production/javaSE/J20250716/demo05_codeblocks/代码块.txt
@@ -0,0 +1,42 @@
 
				+代码块
			
 
				+Java中使用{}括起来的代码被称为代码块
			
 
				+代码块分为三种：
			
 
				+    1、局部代码块
			
 
				+    2、成员代码块
			
 
				+    3、静态代码块
			
 
				+1、局部代码块
			
 
				+    局部代码块在方法中定义。比如：
			
 
				+    public void method(){
			
 
				+        {
			
 
				+            //这就是代码块
			
 
				+        }
			
 
				+    }
			
 
				+    作用，就是限制变量的生命周期，提早释放，提高内存的使用效率
			
 
				+2、成员代码块
			
 
				+    成员代码块在类中方法的外部进行定义，每次执行构造方法的时候，
			
 
				+    都会执行代码块里面的代码，并且是在构造方法之前执行。
			
 
				+    提高代码的复用性，代码块里面的代码，会被所有的构造方法执行。
			
 
				+        格式：
			
 
				+    class 类名{
			
 
				+        {
			
 
				+            //构造代码块
			
 
				+        }
			
 
				+    }
			
 
				+作用：
			
 
				+    在对象加载的时候，做一些数据初始化的操作。
			
 
				+3、静态代码块
			
 
				+    静态代码块也是在类中方法外部定义，但是静态代码块需要使用static修饰
			
 
				+    格式：
			
 
				+    class 类名{
			
 
				+        static{
			
 
				+            //静态代码块
			
 
				+        }
			
 
				+    }
			
 
				+    静态代码块要先于对象执行。
			
 
				+    静态代码块随着类的加载而加载，并且只执行一次。
			
 
				+作用：
			
 
				+    在类加载的时候，做一些数据初始化的操作。
			
 
				+
			
 
				+练习题：
			
 
				+定义 交通工具、汽车、火车、飞机这些类，注意他们之间的继承关系，
			
 
				+并且为这些类提供超过3不同的构造方法，并且通过初始化代码块提取出构造方法中通用的代码。
			
--- a/javaSE/out/production/javaSE/J20250716/继承02.txt
+++ b/javaSE/out/production/javaSE/J20250716/继承02.txt
@@ -0,0 +1,77 @@
 
				+继承中类的成员访问的特点：
			
 
				+成员变量的特点：在子类的方法中访问一个变量，采用的叫就近原则。
			
 
				+    最先在子类局部范围查找
			
 
				+    然后在子类成员范围查找
			
 
				+    最后在父类成员范围查找
			
 
				+    直到都没有，就报错
			
 
				+
			
 
				+super关键字
			
 
				+    this指向的是当前的对象，【我】
			
 
				+    super指向的是当前对象的父类对象，【我爹】
			
 
				+
			
 
				+使用this和super调用方法和变量
			
 
				+    成员变量：
			
 
				+        this.成员变量   -访问本类对象的成员变量
			
 
				+        super.成员变量  -访问父类对象的成员变量
			
 
				+    成员方法：
			
 
				+        this.成员方法   -访问本类对象的成员方法
			
 
				+        super.成员方法   -访问父类对象的成员方法
			
 
				+    构造方法：
			
 
				+        this()  -访问当前对象的构造方法
			
 
				+        super() -访问父类对象的构造方法
			
 
				+
			
 
				+所有的子类，在创建对象的时候，一定一定一定先调用父类的构造方法，然后再调用本类的构造方法创建对象。
			
 
				+子类中所有的构造方法，都会默认的访问父类的无参构造方法。
			
 
				+如果父类没有无参构造方法，那么子类必须在构造方法的[第一行]显式调用父类的有参构造方法并传递参数。
			
 
				+
			
 
				+由于this()和super()都必须在构造方法的第一行，所以二者不能共存
			
 
				+
			
 
				+
			
 
				+父类的方法被子类的同名方法覆盖，这种情况叫方法的【重写】
			
 
				+具体的表现：
			
 
				+    子类中出现了和父类中一模一样的方法声明(方法名相同，参数列表也相同)
			
 
				+
			
 
				+重载和重写的区别：
			
 
				+    重载是发生在同一个类中的，方法名相同，参数列表必须不相同。
			
 
				+    重写是发生在父子类中的，方法名相同，参数列表也必须相同。
			
 
				+
			
 
				+    重写的目的：当子类需要父类的功能，但是功能的主体实现需要子类有自己特定的内容时，就需要重写父类的方法。
			
 
				+
			
 
				+方法重写的注意事项：
			
 
				+    1、private修饰的方法不能被重写，父类的私有成员子类是无法继承的。
			
 
				+    2、子类方法的访问权限不能比父类方法的方法访问权限更低 public>default>private
			
 
				+    3、父类的方法如果想被子类重写，那么就只能属于public或protected修饰
			
 
				+    4、静态方法不能被重写，即使子类有父类相同的方法，也不是重写父类方法，只是方法同名。
			
 
				+
			
 
				+
			
 
				+
			
 
				+案例：
			
 
				+某IT公司有``研发部门``和``设计部门``两个部门的员工，每名员工都有自己的``员工编号``、``员工姓名``、``员工岗位``3个属性，
			
 
				+并且每名员工都有自己的``工作内容``。
			
 
				+比如：
			
 
				+- 员工姓名：张三，工作岗位是：Java开发工程师，员工编号是：1001，工作内容是：开发商城后台管理系统。
			
 
				+- 员工姓名：李四，工作岗位是：前端开发工程师，员工编号是：1011，工作内容是：开发商城首页。
			
 
				+- 员工姓名：王五，工作岗位是：UI设计师，员工编号是2001，工作内容是：商城logo设计。
			
 
				+- 员工姓名：赵六，工作岗位是：UI设计师，员工编号是2002，工作内容是：商城logo设计。
			
 
				+
			
 
				+| 员工类类名         | ``Employee``                |
			
 
				+| ------------------ | --------------------------- |
			
 
				+| 研发部类名         | ``RDDepartment``            |
			
 
				+| 设计部类名         | ``DesignDepartment``        |
			
 
				+| Java开发工程师类名 | ``JavaDevelopmentEngineer`` |
			
 
				+| 前端开发工程师类名 | ``WebDevelopmentEngineer``  |
			
 
				+| UI设计师类名       | ``UIDesigner``              |
			
 
				+| 员工姓名           | ``name``                    |
			
 
				+| 员工编号           | ``id``                      |
			
 
				+| 员工岗位           | ``job``                     |
			
 
				+| 工作方法名         | ``work()``                  |
			
 
				+
			
 
				+请根据上面的信息，合理的编写代码，利用继承相关的知识，实现需求。
			
 
				+
			
 
				+需求：
			
 
				+
			
 
				+- 员工类是父类
			
 
				+- 创建员工类及其各种子类，并分别添加属性和方法。
			
 
				+- 创建提示中的各类员工对象，并为属性赋值，然后调用工作的方法。
			
 
				+- 类名、属性名、方法名必须严格按照表中来写。
			
 
				+- 工作方法中要实现在控制台中输出哪一个部门的哪一个员工，id是什么，岗位是什么，以及在做什么工作内容。
			
--- a/javaSE/out/production/javaSE/J20250717/demo02_interface/img.png
+++ b/javaSE/out/production/javaSE/J20250717/demo02_interface/img.png
--- a/javaSE/out/production/javaSE/J20250717/demo04/多态.txt
+++ b/javaSE/out/production/javaSE/J20250717/demo04/多态.txt
@@ -0,0 +1,52 @@
 
				+面向对象的三大特征：封装、继承、多态
			
 
				+多态
			
 
				+多态就是同一个对象，在不同时刻不同环境表现出来的不同形态。
			
 
				+多态的前提：
			
 
				+    要具有继承关系(继承父类)，或具有实现关系(实现接口)。
			
 
				+    要进行方法的重写。
			
 
				+    要【父类的引用指向子类的对象】
			
 
				+    父类 对象名=new 子类();
			
 
				+
			
 
				+多态有什么好处？
			
 
				+    定义方法的时候，可以使用父类类型作为参数，在使用的时候，使用具体的子类的对象作为实际参数进行操作。
			
 
				+
			
 
				+class 食物{
			
 
				+
			
 
				+}
			
 
				+汉堡、炸鸡、凉皮、米粉、米饭...
			
 
				+
			
 
				+class Person{
			
 
				+
			
 
				+    public void eat(食物 sw){ //在声明形式参数的时候，使用的父类类型的引用变量
			
 
				+
			
 
				+    }
			
 
				+}
			
 
				+Person p=new Person();
			
 
				+p.eat(new 汉堡());    //实际在调用方法并传递实际参数的时候，使用的是子类的对象。
			
 
				+p.eat(new 炸鸡());
			
 
				+p.eat(new 凉皮());
			
 
				+p.eat(new 米粉());
			
 
				+
			
 
				+多态有什么弊端？
			
 
				+    不能使用子类特有的成员。解决方案：向下造型。
			
 
				+
			
 
				+多态的转型：
			
 
				+    向上转型 向上造型：
			
 
				+        父类的引用指向子类的对象，就是向上造型
			
 
				+        Animal a=new Cat();
			
 
				+    向下转型 向下造型：
			
 
				+        子类类型 对象名=(子类类型)父类引用;
			
 
				+        Cat c=(Cat)a;   //强行把父类的对象转化为子类
			
 
				+
			
 
				+向下转型存在的风险和解决方案：
			
 
				+风险：
			
 
				+    向下转型会带来一定的风险，如果对应的实际类型和目标类型不是同一种类型，
			
 
				+    那么在转换的时候就会出现异常：ClassCastException类型强制转换异常
			
 
				+解决方案：
			
 
				+    使用一个关键字 instanceof
			
 
				+    使用的格式：
			
 
				+        变量名(对象名) instanceof 类型
			
 
				+        判断关键字左边的对象名，是不是右边的类型，如果是返回true，否则返回false。
			
 
				+        if(c instanceof Cat){
			
 
				+            Cat c=(Cat)a;
			
 
				+        }
			
--- a/javaSE/out/production/javaSE/J20250717/demo05/题目需求.txt
+++ b/javaSE/out/production/javaSE/J20250717/demo05/题目需求.txt
@@ -0,0 +1,24 @@
 
				+1、需要一个英雄类(Hero)，这个类中包含如下成员属性和方法：
			
 
				+成员属性：
			
 
				+    血量-hp、蓝量-mp、攻击力-attack、移动速度-speed、防御力-defenses
			
 
				+成员方法：
			
 
				+    普通攻击方法(Hero h);
			
 
				+    移动方法();
			
 
				+    技能1(Hero h);-q
			
 
				+    技能2(Hero h);-w
			
 
				+    技能3(Hero h);-e
			
 
				+    大招(Hero h);-r
			
 
				+代码块：如果创建英雄的对象，但是没有进行赋值，那么默认要在代码块中对英雄的属性进行赋值。
			
 
				+    hp=100;
			
 
				+    mp=50;
			
 
				+    attack=15;
			
 
				+    speed=5;
			
 
				+    defenses=10;
			
 
				+
			
 
				+2、创建3个英雄类的子类：亚瑟(YaSe)、妲己(DaJi)、鲁班(LuBan)。默认子类的name属性分别为英雄名
			
 
				+
			
 
				+3、为每个英雄创建一个登场的方法debut()，该方法里进行自我介绍。
			
 
				+
			
 
				+4、召唤师技能(SummonerSkills)类，里面包含4个方法：
			
 
				+        疾跑()、狂暴()、斩杀(Hero h)、惩戒(Hero h)
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250717/接口.txt
+++ b/javaSE/out/production/javaSE/J20250717/接口.txt
@@ -0,0 +1,147 @@
 
				+Java的单继承机制具有一定的局限性。
			
 
				+不能同时继承多个父类，导致子类实现的功能单一。
			
 
				+所以为了弥补这块的不足，Java提出了接口的概念：
			
 
				+
			
 
				+接口
			
 
				+接口是多个功能(抽象方法)的集合。
			
 
				+接口存在的目的就是让子类继承，并重新里面的抽象方法
			
 
				+接口是一种比抽象类还要抽象的类。
			
 
				+接口里没有任何的普通方法，接口里的所有方法必须都是抽象方法。
			
 
				+接口里的方法默认就是抽象的，就是使用：
			
 
				+public abstract修饰的
			
 
				+
			
 
				+
			
 
				+接口就是一种公共的规范标准，只要符合标准，大家都可以使用。
			
 
				+
			
 
				+Java中接口存在的意义：
			
 
				+用来定义规范
			
 
				+用来做功能的扩展
			
 
				+
			
 
				+接口也是类的一种，或者说，接口和类一样都属于引用数据类型
			
 
				+哪些是Java的引用数据类型？
			
 
				+Java中除了8种基本数据类型之外的任意类型都是引用数据类型。
			
 
				+Java中的引用数据类型：
			
 
				+    类   class
			
 
				+    数组
			
 
				+    接口  interface
			
 
				+    枚举
			
 
				+    注解
			
 
				+
			
 
				+定义接口的关键字是：interface
			
 
				+子类实现接口的关键字是：implements
			
 
				+
			
 
				+子类允许实现多个接口。
			
 
				+接口不能实例化，我们不能创建接口的对象，
			
 
				+但是可以创建接口的实习类（子类）的对象
			
 
				+
			
 
				+接口的实现类
			
 
				+要么重写接口中所有的方法
			
 
				+要么该实现类必须是一个抽象类
			
 
				+
			
 
				+接口里的成员变量，默认都是使用public static final修饰的
			
 
				+接口里的任何成员变量，都必须是公共的，静态的，常量
			
 
				+
			
 
				+接口里有构造方法吗？
			
 
				+接口的作用就是为了扩展子类的功能，根据就没有构造方法。
			
 
				+
			
 
				+接口里的方法默认就是public abstract修饰的
			
 
				+只不过在Java8和java9之后增加了一下新特性。
			
 
				+
			
 
				+类和接口的关系：
			
 
				+    类和类之间是继承关系，只能单继承，但是可以多层继承
			
 
				+    类和接口之间是实现关系，可以但实现，也可以多实现。一个实现类可以实现多个接口
			
 
				+    接口和接口之间是继承关系，但是接口之间可以多继承。
			
 
				+
			
 
				+
			
 
				+创建一个接口：UserDao
			
 
				+在里面创建一下方法：
			
 
				+增加用户：addUser()
			
 
				+修改用户：updateUser()
			
 
				+删除用户:deleteUser()
			
 
				+查询用户列表：queryList()
			
 
				+查询单个用户：queryOneUser()
			
 
				+
			
 
				+创建一个实现类：UserDaoImpl
			
 
				+实现UserDao接口，重写所有方法，
			
 
				+比如：
			
 
				+public void addUser(){
			
 
				+    System.out.println("增加用户...");
			
 
				+}
			
 
				+
			
 
				+案例：
			
 
				+定义USB接口(接口具备【开启功能】、【关闭功能】)，笔记本要使用USB设备，
			
 
				+就是笔记本在生产的时候需要预留出可以插入USB设备的USB接口，
			
 
				+就是笔记本【具备使用USB设备的功能】，但是具体是什么USB设备，
			
 
				+笔记本并不关心，只要符合USB规范的设备都可以。鼠标和键盘要想能在笔记本电脑上使用，
			
 
				+那么就必须要符合USB规范，不然即使生产出来也无法使用。
			
 
				+
			
 
				+需求：
			
 
				+- 请描述笔记本类，实现笔记本使用USB鼠标和USB键盘功能
			
 
				+- USB接口具有开启功能``open();``，关闭功能``close();``
			
 
				+- 笔记本类：包含开机功能``run();``，关机功能``shutdown();``,
			
 
				+使用USB设备功能：``useUSB(USB usb);``
			
 
				+- 鼠标类：符合USB接口（实现USB接口）  鼠标开启，鼠标关闭
			
 
				+- 键盘类：符合USB接口（实现USB接口）  键盘开启，键盘关闭
			
 
				+
			
 
				+
			
 
				+接口在Java8和Java9之后先后做了一下修改：
			
 
				+Java8后-接口可以声明【默认方法】：
			
 
				+public default void method(){
			
 
				+
			
 
				+}
			
 
				+作用是解决接口升级的问题。
			
 
				+默认方法不是抽象方法，所以不能强制重写，但是可以被重写，重写的时候去掉default关键字。
			
 
				+默认方法可以省略public关键字，但是不能省略default关键字。
			
 
				+如果实现了多个接口，但是多个接口中存在相同的方法声明，那么子类就必须要对这个方法进行重写。
			
 
				+Java8后-接口可以声明【静态方法】：
			
 
				+public static void method(){
			
 
				+
			
 
				+}
			
 
				+静态方法只能通过接口名调用，不能通过实现类或者对象名调用
			
 
				+public可以省略，static不能省略
			
 
				+
			
 
				+Java9之后-接口增加了私有方法
			
 
				+java9之后增加了带有方法体的私有方法，Java8允许接口中定义带有方法体的默认方法或静态方法。
			
 
				+这样就可能引发一个问题：当两个默认方法或两个静态方法包含一段相同的代码实现。
			
 
				+程序就必须考虑把这段代码抽取成一个共性的方法。但是这个共性方法是不需要让别人使用的，
			
 
				+所以使用私有化private把方法给隐藏起来，就是很有必要的。也就是Java9增加接口的私有方法的原因。
			
 
				+
			
 
				+interface MyInter{
			
 
				+    default void method01(){
			
 
				+        baseMethod()
			
 
				+    }
			
 
				+    default void method02(){
			
 
				+        baseMethod();
			
 
				+    }
			
 
				+    //接口中的私有方法，不让外部使用，只是让自己使用。
			
 
				+    //是当前接口多个方法的相同代码进行抽取得到的。
			
 
				+    private void baseMethod(){
			
 
				+        System.out.println("这是100行代码");
			
 
				+    }
			
 
				+}
			
 
				+注意：
			
 
				+    默认方法可以调用私有的静态方法和非静态方法
			
 
				+    静态方法只可以调用私有的静态方法。
			
 
				+
			
 
				+
			
 
				+
			
 
				+创建一个接口：UserService
			
 
				+在里面创建一下方法：
			
 
				+增加用户：addUser()
			
 
				+修改用户：updateUser()
			
 
				+删除用户:deleteUser()
			
 
				+查询用户列表：queryList()
			
 
				+查询单个用户：queryOneUser()
			
 
				+
			
 
				+创建一个实现类：UserServiceImpl
			
 
				+实现UserService接口，重写所有方法，在方法中分别调用UserDao对象中对应的方法
			
 
				+比如：
			
 
				+UserDao userDao=new UserDao();  //不能创建接口的对象，会报错，因为接口不能创建对象。
			
 
				+UserDaoImpl userDao=new UserDaoImpl();//可以创建接口实现类的对象。
			
 
				+public void addUser(){
			
 
				+    userDao.addUser();
			
 
				+}
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250717/练习.txt
+++ b/javaSE/out/production/javaSE/J20250717/练习.txt
@@ -0,0 +1,11 @@
 
				+
			
 
				+定义一个父类SuperClass，里面有
			
 
				+初始化代码块、
			
 
				+静态初始化代码块、
			
 
				+无参构造方法、有参构造方法、普通方法，普通方法中有局部代码块
			
 
				+定义一个子类SubClass，里面有
			
 
				+       初始化代码块、
			
 
				+       静态初始化代码块、
			
 
				+       无参构造方法、有参构造方法、普通方法，普通方法中有局部代码块，
			
 
				+       并继承父类SuperClass。
			
 
				+定义一个测试类，main方法中创建子类对象，调用方法。
			
--- a/javaSE/out/production/javaSE/J20250718/内部类.txt
+++ b/javaSE/out/production/javaSE/J20250718/内部类.txt
@@ -0,0 +1,79 @@
 
				+class 人{
			
 
				+
			
 
				+    int 心脏;
			
 
				+    肝脏
			
 
				+    脾脏
			
 
				+    胃
			
 
				+    肾脏
			
 
				+    肺
			
 
				+    大肠
			
 
				+    小肠
			
 
				+}
			
 
				+汽车{
			
 
				+    String 发动机
			
 
				+}
			
 
				+
			
 
				+内部类
			
 
				+    在一个类中定义一个类。比如在A类中定义B类，B类就是内部类。
			
 
				+  格式：
			
 
				+    class 外部类名{
			
 
				+        修饰符 class 内部类名{
			
 
				+
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+内部类的特点：
			
 
				+    1、内部类可以直接访问外部类的成员，包括私有的private修饰的。
			
 
				+    2、外部类要访问内部类的成员，就必须要创建对象。
			
 
				+
			
 
				+创建内部类对象的格式：
			
 
				+    //创建内部类的对象
			
 
				+    // 外部类.内部类 内部类对象名=new 外部类().new 内部类();
			
 
				+    Car.Engine ce=new Car().new Engine();
			
 
				+
			
 
				+在一个类中设计内部类的目的，大部分都是不行让外界访问，而是只想自己使用。
			
 
				+所以一般内部类都应该是私有化的，私有化之后，再提供一个可以让外界访问的
			
 
				+方法。方法内部创建内部类的对象并且调用。
			
 
				+
			
 
				+内部类的划分：
			
 
				+    1、成员内部类，建立在类中，方法外。和类的成员处于同一级别。
			
 
				+        |-普通的成员内部类
			
 
				+        |-静态成员内部类
			
 
				+            访问格式：外部类名.内部类名 对象名=new 外部类名.内部类名();
			
 
				+
			
 
				+    2、局部内部类，建立在类中的方法中，属于方法的局部变量级别。
			
 
				+        局部内部类，外界是无法直接访问的，需要在方法的内部类创建对象并使用。
			
 
				+        局部内部类可以直接访问外部类的成员，也可以访问方法内的局部变量。
			
 
				+        //局部内部类，建立在方法中
			
 
				+        public void method() {  //外部类的方法
			
 
				+            class Inner {   //方法内的内部类--局部内部类
			
 
				+                public void show() {    //内部类中的方法
			
 
				+                    System.out.println("内部类的方法...");
			
 
				+                }
			
 
				+            }
			
 
				+            //局部内部类在方法中定义完，就要在方法中使用，否则就没有使用的机会了。
			
 
				+            Inner inner=new Inner();
			
 
				+            inner.show();
			
 
				+        }
			
 
				+    3、匿名内部类
			
 
				+    匿名内部类的前提，先存在一个类或接口，这个类可以是具体类，也可以是抽象类
			
 
				+    匿名内部类的格式：
			
 
				+        new 类名(){
			
 
				+            重写方法
			
 
				+        }
			
 
				+      比如：
			
 
				+        //创建类的对象，后面增加大括号，大括号内部重写类的方法。
			
 
				+        UserDao userDao=new UserDao() {
			
 
				+            @Override
			
 
				+            public void addUser() {
			
 
				+
			
 
				+            }
			
 
				+        };
			
 
				+    匿名内部类的本质：
			
 
				+        其实是一个继承了该类或实现了该接口的子类(实现类)的匿名对象。
			
 
				+        就是创建一个父类(接口)的一次性的子类(实现类)，并且立刻创建这个子类或实现类的对象。
			
 
				+        就又变成了父类的引用，指向子类的对象---多态。
			
 
				+
			
 
				+    匿名内部类在开发中的使用：
			
 
				+        当我们发现了某个方法需要一个接口(抽象类)的子类对象，那么我们就可以传递进去一个匿名内部类，
			
 
				+        简化传统的创建接口或抽象类的子类，然后再创建对象的过程。
			
--- a/javaSE/out/production/javaSE/J20250718/复习.txt
+++ b/javaSE/out/production/javaSE/J20250718/复习.txt
@@ -0,0 +1,22 @@
 
				+接口
			
 
				+是比抽象类还要抽象的类
			
 
				+属于引用数据类型的一种
			
 
				+使用interface关键字修饰
			
 
				+接口里的成员变量全部都是使用public static final修饰的公共的静态常量
			
 
				+接口里的成员方法全部都是使用public abstract修饰的公共的抽象方法。
			
 
				+Java8增加了带有方法体的使用default修饰的默认方法和带有方法体的使用static修饰的静态方法。
			
 
				+Java9增加了带有private修饰的私有方法
			
 
				+实现类实现接口使用关键字：implements
			
 
				+实现类实现接口后，要么重写接口所有的抽象方法，要么实现类必须是抽象类。
			
 
				+实现类可以实现多个接口。并且接口之间的继承可以多继承。
			
 
				+接口不能创建对象，没有构造方法。
			
 
				+
			
 
				+多态
			
 
				+父类的引用指向子类的对象。
			
 
				+多态的含义是一个事物的多种形态。
			
 
				+多态的好处：定义方法的时候，使用父类作为参数。在实际使用的时候使用子类对象参与操作。
			
 
				+弊端：就是不能使用子类的特有成员，解决方案：向下造型。
			
 
				+
			
 
				+父类的引用指向子类的对象，称为向上造型
			
 
				+子类的引用指向父类的对象，称为向下造型
			
 
				+向下造型具有一定的风险，需要使用instanceof关键字进行判断，建议判断结果为true后再进行强转。
			
--- a/javaSE/out/production/javaSE/J20250718/异常.txt
+++ b/javaSE/out/production/javaSE/J20250718/异常.txt
@@ -0,0 +1,89 @@
 
				+异常
			
 
				+    异常就是程序出现了不正常的情况
			
 
				+    Java中的异常体系：
			
 
				+                         Throwable   Java中所有的异常和错误的父类
			
 
				+                       /         \
			
 
				+                Exception         Error
			
 
				+                    /   \
			
 
				+        RuntimeException  Exception
			
 
				+
			
 
				+    Throwable   Java中所有的异常和错误的父类
			
 
				+        |- Exception Java中所有异常的父类，也就是异常类，他表示程序本身可以处理的问题
			
 
				+            |-RuntimeException 运行时异常，程序代码不会报错，但是运行后会报错。
			
 
				+            |-除了RuntimeException类及其子类以外的其他异常，就是程序代码会直接报错，我们必须处理这些异常。
			
 
				+        |-Error Java中所有错误的父类，也就是错误类，他表示不是程序的问题，而是系统的问题。
			
 
				+            如果Java中出现Error错误，那么大部分时间都不是代码的问题，而是系统或内存的问题。
			
 
				+
			
 
				+    Java中的异常分为两大类：
			
 
				+        编译期异常：都是Exception类的子类，必须要我们进行处理，否则程序会发生错误，无法通过编译。
			
 
				+        运行时异常：都是RuntimeException类的子类，不需要我们处理，也可以和编译期异常一样进行处理。
			
 
				+
			
 
				+        Java文件----编译期--》运行期
			
 
				+
			
 
				+        Java程序想要执行，需要几步？
			
 
				+        1、Java源代码文件--->编译(javac.exe)--->Java字节码文件
			
 
				+        Java字节码文件--->解释(java.exe)--->机器码(二进制数据)并且执行
			
 
				+
			
 
				+    我们之前遇到了异常，不做任何处理，都是交给Java虚拟机(JVM)进行处理。
			
 
				+        默认的处理：把异常名称，错误原因，异常出现的位置等信息输出到控制台。并且停止程序继续运行。
			
 
				+
			
 
				+
			
 
				+    我们要进行的异常处理方案：
			
 
				+        两种方案：
			
 
				+            |-1、我们也不处理了，只是把异常告诉虚拟机，这段代码可能出现异常了(声明异常) throws
			
 
				+            |-2、我们进行处理，就比较麻烦了:
			
 
				+                1、我需要先检测可能出现异常的代码块。 try
			
 
				+                2、判断可能出现什么异常并且给出解决方案    catch
			
 
				+                3、无论怎么解决，有些代码必须要执行。     finally
			
 
				+        无论是否处理都会用到的，抛出异常对象  throw
			
 
				+
			
 
				+
			
 
				+    我们可能会自定义一些符合我们业务的异常。
			
 
				+        建一个类，名称后面为Exception，为了区分该类为异常类。
			
 
				+        让该类继承Exception类或RuntimeException类。
			
 
				+
			
 
				+
			
 
				+    万事万物皆为对象
			
 
				+
			
 
				+    throws  用在方法的后面，throws 后面的跟着的是异常类名。表示该方法里面的代码可能会引发某个异常：
			
 
				+    public void method() throws AgeException{   //这个方法里面的代码可能引发AgeException异常。
			
 
				+
			
 
				+    }
			
 
				+    如果哪个方法调用了这个方法，那么就需要进行处理AgeException异常，否则也要使用throws继续声明。
			
 
				+
			
 
				+
			
 
				+    throw 用在方法体里面，后面跟着的是异常的对象名。表示手动抛出异常对象，需要方法体内部进行处理或者throws声明。
			
 
				+
			
 
				+
			
 
				+
			
 
				+我们自己处理异常：
			
 
				+    格式：
			
 
				+        try{
			
 
				+            //是可能出现异常的代码
			
 
				+        }catch(异常类型 变量名){
			
 
				+            //处理方案
			
 
				+        }finally{
			
 
				+            //一定会被执行的代码
			
 
				+        }
			
 
				+案例：
			
 
				+商品类里面包含3个属性：商品名称、商品价格、商品库存
			
 
				+模拟实现用户购买商品的功能，使用ArrayList模拟商品列表，
			
 
				+当购买的商品不存在或者商品库存为0时，抛出自定义异常。
			
 
				+用户购买某一个商品时，对异常进行处理，并对库存进行改变。
			
 
				+
			
 
				+步骤：
			
 
				+    1、创建商品类
			
 
				+    2、创建自定义的异常类：
			
 
				+        NotProductException 没有这个商品异常
			
 
				+        InventoryException 商品库存不足异常
			
 
				+    3、创建Main类
			
 
				+        创建一个购买的方法
			
 
				+        public void shopping(Product p){
			
 
				+
			
 
				+        }
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250718/时间日期工具类.txt
+++ b/javaSE/out/production/javaSE/J20250718/时间日期工具类.txt
@@ -0,0 +1,21 @@
 
				+Java8之前常用的时间日期类
			
 
				+Date类 时间日期类
			
 
				+无参构造方法
			
 
				+Date();分配一个时间日期类对象，精确到毫秒
			
 
				+
			
 
				+计算机所有的时间都是从英国格林威治时间1970年1月1日0点0分0秒0毫秒开始算
			
 
				+北京是东8区
			
 
				+有参构造方法
			
 
				+Date(long date) 分配一个时间日期对象，把他初始化为从基准时间开始到指定的时间的毫秒数
			
 
				+
			
 
				+常用的方法
			
 
				+    getTime()获取时间  是获取的毫秒值。
			
 
				+    setTime()设置时间 给的也是毫秒值
			
 
				+
			
 
				+时间日期的格式化类
			
 
				+SimpleDateFormat类
			
 
				+用来根据区域来设置和格式化日期。
			
 
				+
			
 
				+
			
 
				+Java8之后新增的时间日期类
			
 
				+下周一讲
			
--- a/javaSE/out/production/javaSE/J20250718/练习题.txt
+++ b/javaSE/out/production/javaSE/J20250718/练习题.txt
@@ -0,0 +1,51 @@
 
				+题目 1：成员内部类的基本使用
			
 
				+    编写一个 Java 类 Outer，包含：
			
 
				+    私有成员变量 int x = 10
			
 
				+    成员内部类 Inner，包含：
			
 
				+    方法 printX()：打印外部类的 x 变量
			
 
				+    外部类的方法 createInner()：创建并返回 Inner 对象
			
 
				+    在 main 方法中，创建 Outer 和 Inner 对象，调用 printX() 方法。
			
 
				+
			
 
				+题目 2：静态内部类的使用
			
 
				+    编写一个 Java 类 Calculator，包含：
			
 
				+    静态成员变量 PI = 3.14
			
 
				+    静态内部类 Geometry，包含：
			
 
				+    静态方法 circleArea(double radius)：计算圆面积（使用外部类的 PI）
			
 
				+    非静态方法 rectangleArea(int width, int height)：计算矩形面积
			
 
				+    在 main 方法中，调用 Geometry 的静态和非静态方法。
			
 
				+
			
 
				+题目 4：匿名内部类的使用
			
 
				+    编写一个 Java 接口 Shape，包含：
			
 
				+    抽象方法 double area()
			
 
				+    在 main 方法中，创建 Shape 的匿名内部类对象，表示一个半径为 5 的圆，计算并打印其面积。
			
 
				+
			
 
				+题目 5：内部类的访问权限
			
 
				+    编写一个 Java 类 Enclosing，包含：
			
 
				+    私有成员内部类 PrivateInner，包含：
			
 
				+    私有方法 privateMethod()
			
 
				+    公共方法 accessPrivateInner()：在该方法中创建 PrivateInner 对象并调用其 privateMethod()
			
 
				+    在 main 方法中，创建 Enclosing 对象并调用 accessPrivateInner()。
			
 
				+
			
 
				+题目 6：多重嵌套内部类
			
 
				+    编写一个 Java 类 A，包含：
			
 
				+    成员内部类 B，包含：
			
 
				+    成员内部类 C，包含：
			
 
				+    方法 printMessage()：打印 "Hello from C!"
			
 
				+    在 main 方法中，创建 C 对象并调用 printMessage()。
			
 
				+
			
 
				+题目 7：内部类与外部类的关系
			
 
				+    编写一个 Java 类 OuterClass，包含：
			
 
				+    成员变量 int value = 100
			
 
				+    成员内部类 InnerClass，包含：
			
 
				+    成员变量 int value = 200
			
 
				+    方法 printValues()：分别打印外部类和内部类的 value
			
 
				+    在 main 方法中，创建 InnerClass 对象并调用 printValues()。
			
 
				+
			
 
				+题目 8：内部类实现接口
			
 
				+    编写一个 Java 接口 ClickListener，包含：
			
 
				+    抽象方法 void onClick()
			
 
				+    编写一个 Java 类 Button，包含：
			
 
				+    成员内部类 MyClickListener，实现 ClickListener 接口
			
 
				+    方法 setClickListener(ClickListener listener)：设置点击监听器
			
 
				+    方法 click()：调用监听器的 onClick() 方法
			
 
				+    在 main 方法中，创建 Button 对象，使用匿名内部类设置点击监听器，并调用 click() 方法。
			
--- a/javaSE/out/production/javaSE/J20250721/Lambda表达式.txt
+++ b/javaSE/out/production/javaSE/J20250721/Lambda表达式.txt
@@ -0,0 +1,66 @@
 
				+Lambda表达式
			
 
				+
			
 
				+C语言函数
			
 
				+Java方法
			
 
				+
			
 
				+数学中的函数 ，就是具有输入量、输出量的一套计算方案。也就是用数据进行操作。
			
 
				+
			
 
				+
			
 
				+面向对象的思想强调：必须要通过对象的形式来做事情。
			
 
				+
			
 
				+函数式思想，尽量忽略面向对象的语法，更强调做什么？而不是用什么形式去做。
			
 
				+lambda表达式就是函数式思想。
			
 
				+格式：
			
 
				+    (形式参数)->{
			
 
				+        代码块(行为、操作、运算)
			
 
				+    }
			
 
				+    形式参数：如果有多个参数，每个参数之间使用逗号隔开，没有参数就是空的。
			
 
				+    ->：是英文-和大于号组成。固定的写法。表示指向动作
			
 
				+    代码块{}：表示我们具体要做的事情，也就是方法体内容。
			
 
				+组成lambda表达式的三要素：
			
 
				+    形式参数、箭头、代码块
			
 
				+
			
 
				+
			
 
				+
			
 
				+lambda省略规则：
			
 
				+参数类型可以省略，但是如果有多个参数的情况下，不能只省略一个
			
 
				+    一个参数，省略参数类型：
			
 
				+        //省略参数类型：
			
 
				+        useFlyable((s)->{
			
 
				+            System.out.println(s+"飞......");
			
 
				+        });
			
 
				+    多个参数，省略参数类型
			
 
				+        useFlyable((s,s1)->{
			
 
				+            System.out.println(s+"飞......"+s1);
			
 
				+        });
			
 
				+如果参数有且只有一个那么可以省略小括号：
			
 
				+        useFlyable(s->{
			
 
				+            System.out.println(s+"飞......");
			
 
				+        });
			
 
				+如果代码块的语句只有一条，那么可以省略大括号和分号，和return关键字:
			
 
				+        useAddable((a,b)->a+b);
			
 
				+
			
 
				+
			
 
				+
			
 
				+使用lambda表达式的前提条件，在什么条件下能使用lambda：
			
 
				+1、使用lambda表达式必须要有接口，抽象类都不行。
			
 
				+2、要求接口有且只有一个抽象方法。
			
 
				+
			
 
				+lambda表达式和匿名内部类的区别：
			
 
				+需要的类型不一样：
			
 
				+    1、匿名内部类的父类可以是接口，也可以是抽象类，甚至可以是具体类。
			
 
				+    2、lambda表达式：只能是接口
			
 
				+使用的限制不一样
			
 
				+    如果接口中有且只有一个方法，那么可以使用lambda表达式，也可以使用匿名内部类
			
 
				+    如果接口中有多个抽象方法，那么只能使用匿名内部类，不能使用lambda表达式
			
 
				+实现原理不一样
			
 
				+    匿名内部类：归根结底还是一个单独的类，只不过这个类没有名字，只能使用一次。并且当编译之后，匿名内部类会产生一个单独的.class文件
			
 
				+    lambda表达式：编译之后，是不会编译出单独的.class字节码文件的，对应的字节码会在运行的时候动态生成。
			
 
				+
			
 
				+
			
 
				+当某个接口有且只有一个抽象方法，那么这个接口可以成为函数式接口。
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250722/数据结构.txt
+++ b/javaSE/out/production/javaSE/J20250722/数据结构.txt
@@ -0,0 +1,47 @@
 
				+程序=数据结构+算法
			
 
				+
			
 
				+数据结构的划分：
			
 
				+    1、线性表结构：
			
 
				+        |-栈
			
 
				+        |-队列
			
 
				+        |-数组
			
 
				+        |-链表
			
 
				+    2、树型结构
			
 
				+        二叉树
			
 
				+        ....
			
 
				+    3、图结构
			
 
				+    4、堆结构
			
 
				+    5、散列表结构
			
 
				+
			
 
				+线性表结构-栈和队列
			
 
				+    栈结构：
			
 
				+        先进后出，后进先出。
			
 
				+    队列：
			
 
				+        先进先出，后进后出。
			
 
				+线性表结构-数组和链表
			
 
				+    数组：
			
 
				+        有索引，查询速度快，增删速度慢。
			
 
				+    链表：
			
 
				+        没有索引，每个链表元素都至少有一个指向前一个或后一个元素地址的指针。
			
 
				+
			
 
				+
			
 
				+List集合的底层数据结构就是线性表
			
 
				+    List集合接口有很多的实现类，用来实现：
			
 
				+        数组    [ArrayList]
			
 
				+        栈   Stack
			
 
				+        队列  Queue
			
 
				+        链表  [LinkedList]
			
 
				+ArrayList类是List集合的实现类，底层使用的是动态数组实现的结合
			
 
				+
			
 
				+LinkedList类是List集合的实现类，底层使用的是双向链表
			
 
				+LinkedList特有的方法
			
 
				+    addFirst(E e) 在集合的开头位置添加指定的元素
			
 
				+    addLast(E e) 在集合的末尾位置添加指定的元素
			
 
				+    getFirst(); 获取头元素
			
 
				+    getLast()   获取尾部元素
			
 
				+    removeFirst()  移除头元素
			
 
				+    removeLast()   移除尾部元素
			
 
				+LinkedList自己就可以实现三种数据结构：
			
 
				+    链表
			
 
				+    栈
			
 
				+    队列
			
--- a/javaSE/out/production/javaSE/J20250722/泛型.txt
+++ b/javaSE/out/production/javaSE/J20250722/泛型.txt
@@ -0,0 +1,25 @@
 
				+泛型
			
 
				+是JDK1.5中引入的一个特性，提供了编译时进行类型安全检查的机制。
			
 
				+
			
 
				+Java最早是sun公司推出语言，主要开发人 詹姆斯·高斯林
			
 
				+sun公司没火起来，Oracle公司火起来了，把sun公司收了
			
 
				+JDK1.5
			
 
				+JDK1.6
			
 
				+JDK1.7
			
 
				+Java8
			
 
				+Java9
			
 
				+Java11
			
 
				+Java17
			
 
				+Java21
			
 
				+Java23
			
 
				+
			
 
				+
			
 
				+泛型的好处：
			
 
				+    把运行期间才会出现的问题提前到了编译期间
			
 
				+    避免了强制类型转换。
			
 
				+泛型的定义格式：
			
 
				+    <类型>:指定一种类型的格式，尖括号里面可以任意书写，一般只会写一个大写字母
			
 
				+    比如：<E>、<T>、<A>
			
 
				+    有点像变量名，变量名可以随便命名，用来表示变量值。
			
 
				+    泛型也可以随便命名，用来代指某个类型。
			
 
				+    泛型就相当于给类添加了参数
			
--- a/javaSE/out/production/javaSE/J20250722/集合.txt
+++ b/javaSE/out/production/javaSE/J20250722/集合.txt
@@ -0,0 +1,162 @@
 
				+集合
			
 
				+
			
 
				+集合和数组的区别
			
 
				+相同点：
			
 
				+    集合和数组都是一种容器，可以存储多个数据。
			
 
				+不同点：
			
 
				+    数组长度不可变，集合的长度是可变的。
			
 
				+    数组可以存储基本数据类型也可以存储引用数据类型
			
 
				+    集合只能存储引用数据类型。如果想存储基本数据类型，需要存储基本数据类型对用的包装器类
			
 
				+   基本类型   类
			
 
				+    byte -> Byte
			
 
				+    short -> Short
			
 
				+    int -> Integer
			
 
				+    long -> Long
			
 
				+    float -> Float
			
 
				+    double -> Double
			
 
				+    char -> Character
			
 
				+    boolean ->Boolean
			
 
				+
			
 
				+Java中集合的类型分为两种：
			
 
				+    单列集合
			
 
				+        有序、可重复
			
 
				+        无序、不可重复
			
 
				+    双列集合
			
 
				+
			
 
				+Collection集合
			
 
				+    是单列集合的顶层接口，它表示一组对象，这些对象也可以称为Collection的元素
			
 
				+    java中不提供关于Collection集合的任何直接实现类，它提供更具体的子接口的实现类。
			
 
				+    没有关于直接实现Collection集合的实现类，但是有Collection集合子接口(List、Set)的实现类
			
 
				+
			
 
				+    如果想要创建Collection集合的对象。
			
 
				+    就需要采用多态的形式，创建Collection集合的实现类对象。比如ArrayList.
			
 
				+
			
 
				+    缺少遍历集合的方式
			
 
				+    Collection集合遍历的方式------迭代器
			
 
				+    迭代器是专门用来遍历集合的。
			
 
				+    迭代器是一个类，也是一个方法。
			
 
				+        //1、调用迭代器方法获取迭代器对象
			
 
				+        Iterator it = c.iterator();
			
 
				+        //再通过迭代器对象，调用方法，结合循环，实现遍历。
			
 
				+        //2、直接使用while循环
			
 
				+        //hasNext() 判断当前的位置的元素是否能被取出。   判断什么时候要结束循环
			
 
				+        //next() 获取当前位置的元素，然后将迭代器指向下一个元素位置。
			
 
				+        while (it.hasNext()){
			
 
				+            Object o = it.next();   //获取元素对象，从集合的最开始，获取一个有一个的元素，赋值给o对象
			
 
				+            //至于后面的操作，是输出，还是做运算，都可以.....
			
 
				+            System.out.println(o);
			
 
				+        }
			
 
				+    foreach迭代器
			
 
				+        格式：
			
 
				+            for(元素类型 变量名 : 集合名){
			
 
				+                //使用变量
			
 
				+            }
			
 
				+
			
 
				+List集合(还是个接口)
			
 
				+    是一种有序的集合，这里面的有序指的是【存取顺序】
			
 
				+    我们可以精确的控制List集合中每个元素的插入位置，我们可以通过整数索引值来访问元素，并且可以搜索列表中的元素
			
 
				+    List允许放重复元素。
			
 
				+List集合的特点：
			
 
				+    1、存取有序
			
 
				+    2、可以重复
			
 
				+    3、有索引
			
 
				+List常用的方法：  (E 其实是泛型，可以使用任何类型，作用其实是规定要向集合中存取的元素类型)
			
 
				+    add(int index，E element)    在指定位置插入指定的元素
			
 
				+    E remove(int index)     删除集合中指定索引值位置的元素，并且返回被删除的元素
			
 
				+    E set(int index, E element) 修改指定索引位置的元素，返回被修改的元素
			
 
				+    E get(int index)  返回指定索引位置的元素。
			
 
				+
			
 
				+List接口是继承于Collection接口的，Collection接口里的方法List也都拥有
			
 
				+
			
 
				+
			
 
				+1、创建一个学生类，包含id、name、age属性，配置构造方法和setter、getter方法
			
 
				+创建ArrayList集合。
			
 
				+ArrayList<Student> list=new ArrayList<>();
			
 
				+list.add();
			
 
				+向集合中添加5个学生对象
			
 
				+获取索引值为3的学生的姓名
			
 
				+移除集合中索引值为4的学生
			
 
				+遍历集合
			
 
				+清空集合。
			
 
				+
			
 
				+2、创建一个教师类，包含id、name、age属性，配置构造方法和setter、getter方法
			
 
				+创建LinkedList集合。
			
 
				+向集合中添加5个教师对象
			
 
				+获取索引值为3的教师的姓名
			
 
				+移除集合中索引值为4的教师
			
 
				+遍历集合
			
 
				+清空集合。
			
 
				+3、创建一个Person类，包含id、name、age属性，配置构造方法和setter、getter方法
			
 
				+创建LinkedList集合。
			
 
				+向集合中添加5个Person对象
			
 
				+获取索引值为3的Person的姓名
			
 
				+移除集合中索引值为4的Person对象
			
 
				+遍历集合
			
 
				+清空集合。
			
 
				+
			
 
				+4、创建一个Person类，包含id、name、age属性，配置构造方法和setter、getter方法
			
 
				+创建ArrayList集合。
			
 
				+向集合中添加5个Person对象
			
 
				+获取索引值为3的Person的姓名
			
 
				+移除集合中索引值为4的Person对象
			
 
				+遍历集合
			
 
				+清空集合。
			
 
				+
			
 
				+
			
 
				+
			
 
				+Set集合
			
 
				+    Set集合不能存储重复元素
			
 
				+    Set集合没有索引，不能使用for循环遍历(可以使用foreach)
			
 
				+
			
 
				+Set集合也是一种接口，继承Collection集合
			
 
				+Set集合常用的实现类分为：
			
 
				+    HashSet
			
 
				+    TreeSet
			
 
				+
			
 
				+HashSet集合
			
 
				+    HashSet集合的底层数据结构是哈希表
			
 
				+    特点存取无序，存入的顺序和取出的顺序不一定一样。
			
 
				+    不能存入重复元素
			
 
				+    没有索引，不能使用for循环遍历
			
 
				+    hashSet集合，其实就是把一个又一个对象进行哈希运算(计算出hash码)后，再根据哈希值的顺序存入到集合中。
			
 
				+    所以，我们存入集合的顺序，和取出元素的顺序是不一致的。
			
 
				+
			
 
				+HashCode(哈希值)
			
 
				+    哈希值是JDK根据对象的地址或字符串或者数字进行计算，算出来的int类型的数值。
			
 
				+    如果想获取某个对象的哈希值，可以调用对象.hashCode()方法。就会返回对象的哈希值。
			
 
				+哈希值(哈希码)特点：
			
 
				+    同一个对象多次调用hashCode()方法，返回的hashCode值是相同的。
			
 
				+    默认的情况下，不同的对象的哈希码值是不同的。
			
 
				+    我们重写hashCode()方法的目的就是实现让不同的对象的哈希值相同。
			
 
				+
			
 
				+使用HashSet集合存储学生对象并且遍历，
			
 
				+- 创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历该集合
			
 
				+- 要求：学生对象的成员变量值相同，我们就认为是同一个对象
			
 
				+
			
 
				+如果要使用HashSet集合存某个类型的对象，那么该类必须要先同时重写equals方法和hashCode方法
			
 
				+
			
 
				+TreeSet集合
			
 
				+    不能存储重复元素
			
 
				+    没有索引
			
 
				+    可以将元素按照规则进行排序
			
 
				+    new TreeSet() 无参构造方法 让元素按照自然排序规则进行排序
			
 
				+    new TreeSet(Comparator c) 根据指定的比较器进行排序
			
 
				+
			
 
				+注意：
			
 
				+    任何存入TreeSet集合的引用类型对象，都必须要继承Comparable接口，并且重写compareTo方法，设定好两个对象的比较规则(比较大小)
			
 
				+
			
 
				+自然排序：自定义类实现Comparable接口，并且重写compareTo方法，根据返回值进行排序
			
 
				+比较器排序：创建TreeSet对象的时候，传递Comparator的实现类对象(匿名内部类、lambda表达式)，
			
 
				+重写compare(o1,o2)方法，然后根据返回值进行排序。
			
 
				+
			
 
				+我们在使用TreeSet集合的时候，默认使用的是自然排序，但是当自然排序不能满足我们的业务需求的时候，就必须要使用比较器排序。
			
 
				+两种方式关于返回值的规则：
			
 
				+    如果返回值是负数，表示当前存入的元素是较小值，存左边。
			
 
				+    如果返回值是0，表示当前存入的元素是重复值，不存。
			
 
				+    如果返回值是正数，表示当前存入的元素是较大值，存右边。
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250723/数据结构-树形结构.txt
+++ b/javaSE/out/production/javaSE/J20250723/数据结构-树形结构.txt
@@ -0,0 +1,69 @@
 
				+数据结构-树型结构
			
 
				+度：节点拥有的子节点的数量称为节点的度数（Degree），而树的度数是所有节点中度数的最大值。
			
 
				+树的种类：
			
 
				+1、二叉树
			
 
				+    二叉树中，任意的一个节点的度必须小于或等于2
			
 
				+    节点：在树结构中，每一个元素称为节点
			
 
				+    度：每一个节点的子节点的个数。
			
 
				+2、二叉查找树
			
 
				+    二叉查找树也叫【二叉排序树】，也叫【二叉搜索树】
			
 
				+    每一个节点上最多有两个子节点。
			
 
				+    左子树上所有节点的值都小于根节点的值
			
 
				+    右子树上所有节点的值都大于根节点的值
			
 
				+二叉查找树添加子节点的时候，要求：
			
 
				+    比父节点小的放左边
			
 
				+    比父节点大的放右边
			
 
				+    一样的不放
			
 
				+3、平衡二叉搜索树 AVL树
			
 
				+    要求二叉树的左右子树的高度差不能超过1。
			
 
				+    要求任意的节点的左右两个子树都是一棵平衡二叉树
			
 
				+    平衡二叉树旋转
			
 
				+        旋转触发的时机：当添加一个节点之后，这棵树不再是平衡二叉树的时候，就会进行旋转。
			
 
				+    二叉树的旋转：
			
 
				+    左旋：
			
 
				+        把根节点右侧往左拉，原来的右子节点变为新的父节点，并且把多余的左子节点让出，
			
 
				+        给降级的根节点当右子节点。
			
 
				+
			
 
				+    右旋：
			
 
				+        就是把根节点左侧往右拉，原来的左子节点变为新的父节点，并且把多余的右子节点让出，
			
 
				+        给降级的根节点当左子节点。
			
 
				+    触发平衡二叉树旋转的四种情况：
			
 
				+    左左：
			
 
				+        当根节点左子树的左子树有节点插入，导致二叉树不平衡。
			
 
				+        旋转方式：直接对整体进行右旋即可
			
 
				+    左右：
			
 
				+        当根节点左子树的右子树有节点插入，导致二叉树不平衡。
			
 
				+        旋转方式：先在左子树对应的节点位置进行左旋，然后再对整体进行右旋
			
 
				+    右右：
			
 
				+        当根节点右子树的右子树有节点插入，导致二叉树不平衡。
			
 
				+        旋转方式：直接对整体进行左旋即可
			
 
				+    右左：
			
 
				+        当根节点右子树的左子树有节点插入，导致二叉树不平衡。
			
 
				+        旋转方式：先在右子树对应的节点位置进行右旋，然后再对整体进行左旋
			
 
				+4、红黑树
			
 
				+    每一个节点可以是【红】或者是【黑】
			
 
				+    红黑树不是高度平衡的，它的平衡是通过自己的【红黑规则】来实现的
			
 
				+红黑规则：
			
 
				+    1、每一个节点要么是红色的，要么是黑色的。
			
 
				+    2、根节点必须是黑色的。
			
 
				+    3、如果一个节点没有子节点(叶子节点)或者没有父节点(根节点)，
			
 
				+    那么该节点相应的指针属性值为Nil，这些Nil是为叶子节点，每个叶子节点是黑色的。
			
 
				+    4、如果一个节点是红色的，那么它的子节点必须是黑色的(不能出现两个红色节点相连的情况)
			
 
				+    5、每一个节点，从该节点开始到后面的所有叶子节点的简单路径上，都要包含相同个数的黑色节点。
			
 
				+
			
 
				+添加节点的时候，新节点的颜色可以是红色也可以是黑色。建议默认的颜色是红色，可以提高效率。
			
 
				+
			
 
				+当我们添加节点后，为了保持红黑规则：
			
 
				+    根节点位置，建议直接设置为黑色。
			
 
				+    非根节点位置，
			
 
				+        |-如果父节点是黑色，那么不用做任何操作，子节点默认红色就行。
			
 
				+        |-如果父节点是红色，
			
 
				+            |-叔叔节点也为红色
			
 
				+                把父节点设置为黑色，把叔叔节点设置为黑色
			
 
				+                把祖父节点设置为红色
			
 
				+                如果祖父节点是根节点，就再次把根节点设置为黑色
			
 
				+            |-叔叔节点为黑色
			
 
				+                把父节点设置为黑色
			
 
				+                把祖父节点设置为红色
			
 
				+                再以祖父节点为支点进行旋转
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250723/练习题.txt
+++ b/javaSE/out/production/javaSE/J20250723/练习题.txt
@@ -0,0 +1,10 @@
 
				+1、HashSet 存储自定义对象
			
 
				+需求：
			
 
				+定义 Student 类（包含 name 和 age），创建 HashSet 存储 3 个 Student 对象
			
 
				+（其中 2 个属性完全相同），确保 HashSet 能正确去重（需重写 hashCode () 和 equals ()）。
			
 
				+2、TreeSet 存储自定义对象（自然排序）
			
 
				+需求：
			
 
				+定义 Book 类实现 Comparable<Book>接口（按价格排序），创建 TreeSet 存储 3 本不同价格的 Book，遍历输出验证排序效果
			
 
				+3、HashSet 与 TreeSet 转换
			
 
				+需求：
			
 
				+创建 HashSet 存储字符串 ["dog", "cat", "bird", "cat"]，将其转换为 TreeSet，观察转换后元素的顺序变化并输出。
			
--- a/javaSE/out/production/javaSE/J20250723/集合_Map.txt
+++ b/javaSE/out/production/javaSE/J20250723/集合_Map.txt
@@ -0,0 +1,76 @@
 
				+Java集合---Map
			
 
				+Map集合属于双列集合。
			
 
				+每一组集合元素，包含一个键(key)，和一个值(value)。
			
 
				+Map集合接口：
			
 
				+    interface Map<K,V>{....}
			
 
				+    K:键的类型
			
 
				+    V:值的类型
			
 
				+键不可以重复，值可以重复
			
 
				+Map集合接口常用的实现类有两个：
			
 
				+    HashMap
			
 
				+    TreeMap
			
 
				+Set集合系列的HashSet就是使用HashMap的键来实现的。
			
 
				+Set集合系列的TreeSet就是使用TreeMap的键来实现的。
			
 
				+
			
 
				+创建Map集合的对象HashMap
			
 
				+    Map<String,String> map=new HashMap<>();
			
 
				+向map集合中添加元素：
			
 
				+    V put(K key,V value)    添加元素，参数是键和值
			
 
				+  比如：
			
 
				+    map.put("1001","张三");
			
 
				+    map.put("1002","李四");
			
 
				+从集合总移除元素：
			
 
				+    V remove(Object key);   移除元素，参数是要移除的key键,返回的被移除的Value值
			
 
				+  比如：
			
 
				+    map.remove("1001");
			
 
				+清空集合
			
 
				+    void clear()    移除集合中所有的键值对元素
			
 
				+判断集合中是否包含指定的键
			
 
				+    boolean containKey(Object key)
			
 
				+判断集合中是否包含指定的值
			
 
				+    boolean containValue(Object value)
			
 
				+判断集合是否为空
			
 
				+    boolean isEmpty()
			
 
				+返回集合的长度
			
 
				+    int size();
			
 
				+
			
 
				+获取Map集合中的元素
			
 
				+根据键获取值          V get(K key)
			
 
				+获取所有键的集合        Set<K> keySet()
			
 
				+获取所有值的集合        Collection<V> values()
			
 
				+获取所有键值对对象的集合    Set<Map.Entry<K,V>> entrySet()
			
 
				+
			
 
				+//尝试一下，遍历map集合
			
 
				+    1、先获取所有键的集合
			
 
				+    2、使用foreach循环，遍历键的集合
			
 
				+    3、循环内根据键获取值
			
 
				+
			
 
				+HashMap集合
			
 
				+HashMap集合的底层是哈希表结构的，依赖hashCode方法和equals方法来保证集合键的唯一。
			
 
				+如果键要存的是自定义对象，我们自己创建的类的对象，那么这个类必须要重写hashCode和equals方法
			
 
				+
			
 
				+map.put(k,v);
			
 
				+
			
 
				+
			
 
				+在集合中和之前的元素进行比较，
			
 
				+    hashCode值 如果不一样，直接存进集合。如果一样，就比较equals。
			
 
				+    equals返回结果是否为true，如果有为true的，那么这个元素就覆盖之前的那个元素。
			
 
				+    比如：
			
 
				+    [<k,v>,<k1,v1>,<k2,v2>]
			
 
				+    <k3,v2>
			
 
				+    如果：
			
 
				+        新添加到集合的元素的key的hashCode值和集合中其他元素的Key的hashCode值都不一样，就直接插入集合。
			
 
				+    如果，hashCode值一样。但是equals比较后返回false，那么就以链表的形式挂到hashCode值相同的元素的后面。
			
 
				+    如果，hashCode值一样，equals也一样，就覆盖原来的元素
			
 
				+
			
 
				+
			
 
				+案例需求：
			
 
				+- 创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。
			
 
				+- 要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象(重写equals和hashCode方法)
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250723/集合复习.txt
+++ b/javaSE/out/production/javaSE/J20250723/集合复习.txt
@@ -0,0 +1,8 @@
 
				+LinkedList 集合
			
 
				+底层是双向链表结构
			
 
				+
			
 
				+queue 队列
			
 
				+double queue Deque 双端队列
			
 
				+使用LinkedList实现栈数据结构的压栈(入栈)、弹栈(出栈)
			
 
				+压栈方法：push(E e)
			
 
				+弹栈方法：pop()
			
--- a/javaSE/out/production/javaSE/J20250724/demo01/练习题.txt
+++ b/javaSE/out/production/javaSE/J20250724/demo01/练习题.txt
@@ -0,0 +1,51 @@
 
				+HashSet去重特性
			
 
				+要求：
			
 
				+1、创建包含重复元素的HashSet（数据：5, 2, 5, 9, 2）
			
 
				+2、添加新元素：7
			
 
				+3、检查元素9是否存在
			
 
				+4、打印集合大小和所有元素
			
 
				+预期输出：
			
 
				+Size: 4
			
 
				+Elements: [2, 5, 7, 9]  // 顺序可能不同
			
 
				+
			
 
				+TreeSet排序特性
			
 
				+1、创建TreeSet存储整数（数据：15, 8, 23, 4, 42）
			
 
				+2、获取第一个和最后一个元素
			
 
				+3、打印大于10的元素
			
 
				+预期输出：
			
 
				+First: 4, Last: 42
			
 
				+Elements >10: [15, 23, 42]
			
 
				+
			
 
				+
			
 
				+、需求：设计一个电商系统，包含以下组件：
			
 
				+
			
 
				+1.	抽象类 Product：
			
 
				+o	私有成员 id, name, price
			
 
				+o	抽象方法 double getDiscountPrice()
			
 
				+2.	接口 Taxable：
			
 
				+o	方法 double calculateTax()
			
 
				+3.	具体类 Electronics（继承 Product 并实现 Taxable）：
			
 
				+o	私有成员 warrantyYears
			
 
				+o	实现 getDiscountPrice() 和 calculateTax()
			
 
				+4.	具体类 Clothing（继承 Product）：
			
 
				+o	私有成员 size
			
 
				+o	实现 getDiscountPrice()
			
 
				+5.	异常类 InvalidPriceException：
			
 
				+o	当价格为负数时抛出
			
 
				+6.	订单类 Order：
			
 
				+o	私有成员 ArrayList<Product> products
			
 
				+o	方法 addProduct(Product p)（处理异常）
			
 
				+o	方法 calculateTotal()（计算总价，含税费）
			
 
				+7.	测试类 EcommerceSystem：
			
 
				+o	创建不同产品并添加到订单
			
 
				+o	处理异常并计算总价
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250724/函数式编程.txt
+++ b/javaSE/out/production/javaSE/J20250724/函数式编程.txt
@@ -0,0 +1,55 @@
 
				+函数式编程
			
 
				+Stream流的三类方法：
			
 
				+    1、获取Stream流
			
 
				+        创建了一条流水线
			
 
				+    2、中间方法
			
 
				+        在流水线上进行的操作
			
 
				+        一次操作后，还可以继续进行操作
			
 
				+    3、终结方法
			
 
				+        一个Stream流只能有一个终结方法
			
 
				+        是流水线上最后一个操作
			
 
				+
			
 
				+一部分：生成Stream流的方式：
			
 
				+    1、Collection体系的集合
			
 
				+        可以使用默认方法stream()生成流
			
 
				+        default Stream<E> stream()
			
 
				+    2、Map体系集合
			
 
				+        把Map转换成Set集合，间接的生成流
			
 
				+    3、数组
			
 
				+        通过Arrays类中的静态方法stream()生成流
			
 
				+    4、同种数据类型的多个数据
			
 
				+        通过Stream接口的静态方法of(T...values)生成流
			
 
				+
			
 
				+二部分：中间操作方法
			
 
				+        中间操作的意思，执行完毕当前的方法后，Stream可以继续执行其他操作
			
 
				+        Stream<T> filter()  对流中的数据进行过滤
			
 
				+        Stream<T> limit()   返回这个流中的元素组成的流，截取指定参数个数的数据
			
 
				+        Stream<T> skip()    跳过指定参数个数的数据，返回有该流剩余的元素组成的流
			
 
				+        static<T> Stream<T> concat(Stream a,Stream b) 合并a和b两个流为一个流
			
 
				+        Stream<T> distinct()    返回这个流的不同元素(使用equals比较)组成的流
			
 
				+
			
 
				+三部分：终结操作
			
 
				+    终结操作指的是操作玩次方法后，Stream流就不能再执行其他操作了。
			
 
				+    void forEach(Consumer action)   对当前流的每个元素执行操作
			
 
				+    long count()    返回当前流中的元素数
			
 
				+
			
 
				+
			
 
				+收集操作
			
 
				+    把数据使用Stream流的方式操作完毕后，再把流中的数据收集到集合中。
			
 
				+    R collect(Collector collector)  把结果收集到集合中。
			
 
				+
			
 
				+    工具类Collectors提供了具体的收集方式：
			
 
				+    public static<T> Collector toList() 把元素收集到List集合
			
 
				+    public static<T> Collector toSet() 把元素收集到List集合
			
 
				+    public static<T> Collector toMap() 把元素收集到List集合
			
 
				+
			
 
				+
			
 
				+引用类的静态方法
			
 
				+    类名::方法名
			
 
				+    System.out::println
			
 
				+    使用它的前提：
			
 
				+    如果我们在重写方法的时候，方法体只有一行代码，并且这个代码是调用了某个类的静态方法，
			
 
				+    并且我们要重写的抽象方法中所有的参数都是按照顺序传入到了这个静态方法中，这个时候我们就可以引用类的静态方法
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250724/文件.txt
+++ b/javaSE/out/production/javaSE/J20250724/文件.txt
@@ -0,0 +1,57 @@
 
				+文件File
			
 
				+创建File对象的方式：
			
 
				+new File(String pathname)   创建文件对象
			
 
				+new File(String parent,String child)
			
 
				+    parent 父路径
			
 
				+    child  子路径
			
 
				+//第一中方式创建File对象
			
 
				+File file=new File("D:/今天天挺好.txt");
			
 
				+//第二种方式创建File对象，使用父路径+子路径
			
 
				+File file2=new File("D:/","函数式编程.txt");
			
 
				+//第三种方式
			
 
				+//file对象作为父路径，字符串是子路径
			
 
				+File file3=new File("D:/");
			
 
				+File file4=new File(file3,"函数式编程.txt");
			
 
				+
			
 
				+
			
 
				+判断功能：
			
 
				+    判断当前的File的路径是否为目录(文件夹)  isDirectory()
			
 
				+    判断当前的File路径是否为文件    isFile()
			
 
				+    判断当前的路径是否存在 exits()
			
 
				+
			
 
				+绝对路径：
			
 
				+    Windows系统中，从盘符开始 C盘、D盘直到某个文件或文件夹的路径叫绝对路径.
			
 
				+    绝对路径指的是从根目录开始的路径
			
 
				+    D:\Code\javaProjects\javaSE\src\J20250722
			
 
				+相对路径：
			
 
				+    相对于当前的文件的路径，./指的是和当前文件在同一个文件夹下的其他文件
			
 
				+    ../指的是当前的文件所属文件夹的上一层文件夹中
			
 
				+    ./abc.txt 当前文件夹下的abc.txt文件
			
 
				+    ../abc.txt 当前文件夹的上一层文件夹中的abc.txt文件
			
 
				+获取功能:
			
 
				+    获取当前路径的绝对路径 getAbsolutePath()
			
 
				+    获取路径名字符串    getPath()
			
 
				+    获取文件名或目录名   getName()
			
 
				+    获取目录中的文件和目录组成的File对象数组  listFile();
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+- 案例需求
			
 
				+    在当前模块下的aaa文件夹中创建一个a.txt文件
			
 
				+
			
 
				+- 实现步骤
			
 
				+    - 创建File对象,指向aaa文件夹
			
 
				+    - 判断aaa文件夹是否存在,如果不存在则创建
			
 
				+    - 创建File对象,指向aaa文件夹下的a.txt文件
			
 
				+    - 创建这个文件
			
 
				+
			
 
				+- 案例需求
			
 
				+    删除一个多级文件夹
			
 
				+- 实现步骤
			
 
				+    - 定义一个方法,接收一个File对象
			
 
				+    - 遍历这个File对象,获取它下边的每个文件和文件夹对象
			
 
				+    - 判断当前遍历到的File对象是文件还是文件夹
			
 
				+    - 如果是文件,直接删除
			
 
				+    - 如果是文件夹,递归调用自己,将当前遍历到的File对象当做参数传递
			
 
				+    - 参数传递过来的文件夹File对象已经处理完成,最后直接删除这个空文件夹
			
--- a/javaSE/out/production/javaSE/J20250724/递归.txt
+++ b/javaSE/out/production/javaSE/J20250724/递归.txt
@@ -0,0 +1,7 @@
 
				+递归
			
 
				+    从编程的角度来说，递归是在方法定义中调用方法本身的现象。
			
 
				+    其实本质是把一个复杂的问题一层层的转换为和原来的问题相似的，但是规模更小的问题来求解。
			
 
				+    递归策略只需要比较简单的程序就可以描述出解题过程需要的多次的计算
			
 
				+
			
 
				+递归一定要有出口，否则会内存溢出
			
 
				+即使有出口，递归的次数也不能太多，否则还是会内存溢出
			
--- a/javaSE/out/production/javaSE/J20250725/IO流.txt
+++ b/javaSE/out/production/javaSE/J20250725/IO流.txt
@@ -0,0 +1,133 @@
 
				+IO流
			
 
				+    I  input 输入
			
 
				+    O  Output 输出
			
 
				+    流：Stream是一种抽象的概念，是对数据传输的总称，
			
 
				+    也就是说数据在设备直接进行传输就称为流。流的本质是数据传输。
			
 
				+    IO流就是用来处理设备之间的传输问题的，比较常见的应用：文件上传、文件下载、文件复制
			
 
				+
			
 
				+基础流：
			
 
				+    IO流的分类：
			
 
				+    按照流向分类
			
 
				+        输入流：读数据
			
 
				+        输出流：写数据
			
 
				+    按照流的数据类型分类：
			
 
				+        字节流
			
 
				+            字节输入流
			
 
				+            字节输出流
			
 
				+        字符流
			
 
				+            字符输入流
			
 
				+            字符输出流
			
 
				+
			
 
				+IO流的使用场景
			
 
				+    如果操作的是纯文本文件，优先使用字符流
			
 
				+    如果操作的是图片、视频、音频、有格式文本等等二进制文件，那么一定要使用字节流。
			
 
				+    如果操作的文件类型不确定，优先使用字节流。
			
 
				+
			
 
				+字节流：
			
 
				+    字节流基类(父类):
			
 
				+        InputStream     这个抽象类是所有字节输入流类的父类
			
 
				+        OutputStream    这个抽象类是所有字节输出流类的父类
			
 
				+    文件字节输入流：FileInputStream 是InputStream的子类，专门用来做文件的输入操作
			
 
				+    它操作文件数据的方法：read()
			
 
				+
			
 
				+    文件字节输出流：FileOutputStream 是OutputStream的子类，专门用来做文件的输出操作
			
 
				+    它操作文件数据的方法：write()
			
 
				+    write(int b)    写入一个字节
			
 
				+    write(byte[] bytes) 写入一个字节数组
			
 
				+    write(byte[] bytes,int off,int len) 写入一个字节数组，从off开始写入len长度个字节。
			
 
				+
			
 
				+    //Windows系统换行 \r\n
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+案例：
			
 
				+    结合23种设计模式中的模板模式，实现如下操作：
			
 
				+    调用该方法并传入参数后，会在D盘中创建《title》.txt文件，并在文件中自动写出文章。
			
 
				+    public static boolean AutoWriting(String title){
			
 
				+
			
 
				+        return true;
			
 
				+    }
			
 
				+
			
 
				+-[模板设计模式]
			
 
				+把抽象类整体看成一种模板，模板种不能决定的东西都定义为抽象方法。
			
 
				+让使用模板的类(继承抽象类的类)，去重写抽象方法，自己实现需求。
			
 
				+模板设计模式的优势：
			
 
				+    模板已经定义了通用的结构，使用的人只需要关心自己要实现的功能就可以了。
			
 
				+
			
 
				+abstract class 作文模板类{
			
 
				+    public void write(){
			
 
				+        System.out.println("《我的爸爸》");
			
 
				+        body();
			
 
				+        System.out.println("啊~这就是我的爸爸！");
			
 
				+    }
			
 
				+    public abstract void body();
			
 
				+}
			
 
				+
			
 
				+处理流：
			
 
				+    基于基础流进行的强化，比如缓冲流。因为是对基础流的强化，所以创建处理流的时候，构造方法的参数是基础流对象
			
 
				+    字节缓冲流
			
 
				+        |-字节缓存输入流   BufferedInputStream
			
 
				+            new BufferedInputStream(new FileInputStream());
			
 
				+        |-字节缓存输出流   BufferedOutPutStream
			
 
				+    字符缓冲流
			
 
				+
			
 
				+
			
 
				+字符流：
			
 
				+    字符流=字节流+字符编码表
			
 
				+字符编码表--字符集
			
 
				+    字符集是一个系统支持的所有字符的集合，包括各个国家的文字、标点符号、图形符号、数字等等
			
 
				+    计算机想要准确的存储和识别各种字符集符号，就需要进行字符编码，一套字符集必须要有一套编码表。
			
 
				+    常见的字符集：ASCII字符集，GB-XXXX字符集 Unicode字符集
			
 
				+
			
 
				+    把字符串转换为字节的方法：
			
 
				+        byte[] getBytes();  使用平台默认的字符集把String类型字符串转换为一系列字节。
			
 
				+        byte[] getBytes(String charsetName);    使用指定的字符集把String类型字符串转换为一系列字节。
			
 
				+        new String(byte[] bytes);  使用平台默认的字符集把一系列字节转换为String类型字符串
			
 
				+        new String(byte[] bytes,charsetName);使用指定的字符集把一系列字节转换为String类型字符串
			
 
				+
			
 
				+字符流：
			
 
				+    输入字符流-抽象类 Reader
			
 
				+        |-文件输入字符流 FileReader
			
 
				+            |-构造方法：
			
 
				+                |- new FileReader(File file)
			
 
				+                |- new FileReader(String fileName)
			
 
				+            |-成员方法：
			
 
				+                |- int read() 一次读取一个字符数据
			
 
				+                |- int read(char[] cbuf) 一次读取一个字符数组数据
			
 
				+
			
 
				+    输出字符流-抽象类 Writer
			
 
				+        |-文件输出字符流   FileWriter
			
 
				+            |-构造方法：
			
 
				+                |-  new FileWriter(File file)
			
 
				+                |-  new FileWriter(File file,boolean append)
			
 
				+                |-  new FileWriter(String pathName)
			
 
				+                |-  new FileWriter(String pathName,boolean append)
			
 
				+            |-普通方法：
			
 
				+                |- void write(int c)    写一个字符
			
 
				+                |- void write(char[] cbuf)  写一个字符数组
			
 
				+                |- void write(String str)   写一个字符串
			
 
				+                |- void write(String str,int off,int len)   写一个字符串的一部分
			
 
				+                |- flush() 刷新流，刷新后还可以继续写数据。
			
 
				+                |- close() 关闭流
			
 
				+
			
 
				+案例需求： 用户注册
			
 
				+    - 编写方法代码，实现用户的用户名和密码保存到本地实现永久化存储
			
 
				+    public static boolean registerUser(String username,String password){
			
 
				+        return false;
			
 
				+    }
			
 
				+- 实现步骤
			
 
				+    - 获取用户输入的用户名和密码
			
 
				+    - 将用户输入的用户名和密码写入到本地文件中
			
 
				+    - 关流,释放资源
			
 
				+
			
 
				+处理流：
			
 
				+    基于基础流进行的强化，比如缓冲流。因为是对基础流的强化，所以创建处理流的时候，构造方法的参数是基础流对象
			
 
				+    字符缓冲流
			
 
				+        |- 字符缓冲输入流
			
 
				+            BufferedReader
			
 
				+                |-特有方法：String readLine() 读取一行文字，结果包含行的内容的字符串，不包含任何终止字符，如果已经到达流的结尾，则为null。
			
 
				+        |- 字符缓冲输出流
			
 
				+            BufferedWriter
			
 
				+                |-特有方法：void newLine() 写一行行分隔符，行分隔符字符串有系统属性定义。
			
--- a/javaSE/out/production/javaSE/J20250728/IO流.txt
+++ b/javaSE/out/production/javaSE/J20250728/IO流.txt
@@ -0,0 +1,22 @@
 
				+对象序列化---对象持久化
			
 
				+就是把对象保存到磁盘，或在网络中进行传输
			
 
				+这种机制就是使用一个字节序列来表示对象，这个字节序列包括：对象的类型，对象的数据、对象中存储的属性信息
			
 
				+字节序列写到文件之后，就相当于在文件中持久保存了一个对象的信息。
			
 
				+相反的，这个字节序列也可以从文件中读取回来，重构对象，进行反序列化
			
 
				+ObjectOutputStream  把对象进行持久化保存
			
 
				+ObjectInputStream   把对象进行反序列化
			
 
				+它们也是处理流，处理的是基础流。
			
 
				+注意：
			
 
				+    所有要进行序列化的类，都必须要实现一个接口 Serializable接口。
			
 
				+    并且建议在要序列化的类中，添加一个成员变量，该变量使用private static final 修饰：
			
 
				+    private static final long serialVersionUID=42L;
			
 
				+
			
 
				+- 案例需求
			
 
				+    创建多个学生类对象写到文件中,再次读取到内存中
			
 
				+- 实现步骤
			
 
				+    - 创建序列化流对象
			
 
				+    - 创建多个学生对象（序列化多个对象，不建议直接把多个对象序列化到同一文件中，建议使用集合）
			
 
				+    - 将学生对象添加到集合中
			
 
				+    - 将集合对象序列化到文件中
			
 
				+    - 创建反序列化流对象
			
 
				+    - 将文件中的对象数据,读取到内存中
			
--- a/javaSE/out/production/javaSE/J20250728/Properties.txt
+++ b/javaSE/out/production/javaSE/J20250728/Properties.txt
@@ -0,0 +1,23 @@
 
				+Properties集合
			
 
				+是Map集合的实现类，是Map集合体系下的集合
			
 
				+Properties是可以保存到流中，或者可以从流中进行加载
			
 
				+Properties其实就是一个属性列表
			
 
				+列表中的每一个键和它对应的值都是一个字符串
			
 
				+
			
 
				+Properties特有的方法：
			
 
				+    Object setProperty(String key,String value) 设置集合的键和值，底层调用的是Hashtable的方法put
			
 
				+    String getProperty(String key) 根据key获取属性列表中的value
			
 
				+    Set<String> stringPropertyNames() 从这个属性列表中返回一个不可修改的Set集合，键和它对应的值是字符串
			
 
				+
			
 
				+Properties和IO流结合使用的方法
			
 
				+    void load(Reader reader) 从字符输入流中读取属性列表(元素的键值对)
			
 
				+    void store(Writer writer,String comments) 把当前的属性列表写入到Properties中，
			
 
				+    以适合使用load读取的方式进行写入。
			
 
				+
			
 
				+
			
 
				+- 案例需求
			
 
				+    在Properties文件中手动写上姓名和年龄,读取到集合中,将该数据封装成学生对象,写到本地文件
			
 
				+- 实现步骤
			
 
				+    - 创建Properties集合,将本地文件中的数据加载到集合中
			
 
				+    - 获取集合中的键值对数据,封装到学生对象中
			
 
				+    - 创建序列化流对象,将学生对象序列化到本地文件中
			
--- a/javaSE/out/production/javaSE/J20250730/多线程.txt
+++ b/javaSE/out/production/javaSE/J20250730/多线程.txt
@@ -0,0 +1,197 @@
 
				+程序的并行和并发：
			
 
				+并行：在同一个时刻，有多个指令在多个CPU(运算器+控制器--计算机核心)上同时执行。
			
 
				+并发：在同一个时刻，多个指令在单个CPU上交替执行。
			
 
				+
			
 
				+程序的进程和线程：
			
 
				+进程：就是正在运行的程序。
			
 
				+一个程序一旦运行起来，就会通过输入流进入到内存运行起来。变成了进程。
			
 
				+独立性：进程是一个能够独立运行的基本单位，同时也是系统分配资源和调度的独立单位。
			
 
				+动态性：进程的本质是程序的一次执行过程，进程是动态产生，动态消亡。
			
 
				+并发性：任何的进程都可以和其他进程一起并发执行。
			
 
				+
			
 
				+线程：
			
 
				+    是进程中的单个顺序控制了，是一条执行路径。
			
 
				+    单线程：是一个进程中如果只有一条执行路径，就称为是单线程程序。
			
 
				+    多线程：一个进程中如果有多条执行路径，就称为多线程程序。
			
 
				+
			
 
				+Java中实现线程的方式：
			
 
				+方式一：继承Thread类
			
 
				+
			
 
				+方法：
			
 
				+    void run() 当线程开启后，该方法会被调用执行。
			
 
				+    是从Thread类继承过来的，目的是让子类重写。
			
 
				+    void start() 让此线程开始执行，Java虚拟机会自动调用run()方法。
			
 
				+实现步骤：
			
 
				+    1、定义一个类继承Thread类，
			
 
				+    2、在子类中重写Thread类中的run()方法
			
 
				+    3、创建子类的对象
			
 
				+    4、调用start()方法
			
 
				+
			
 
				+方式二：实现Runnable接口
			
 
				+实现步骤：
			
 
				+    1、定义一个类实现Runnable接口
			
 
				+    2、在实现类中重写run方法
			
 
				+    3、创建Thread类的对象，将实现类对象作为构造方法的参数传入
			
 
				+    4、调用Thread类的start方法
			
 
				+
			
 
				+方式三：实现Callable接口-创建带有返回值的线程
			
 
				+
			
 
				+方法：
			
 
				+    V call()    计算结果，如果无法计算结果则抛出一个异常。
			
 
				+    FutureTask(Callable<V> callable)
			
 
				+    创建一个FutureTask，一旦运行，就会执行传入的参数Callable对象的call方法。
			
 
				+    V get() 如果又必要，则等待计算完成，然后获取结果。
			
 
				+
			
 
				+实现步骤：
			
 
				+    1、定义一个类实现Callable接口，并且可以指定泛型
			
 
				+    2、在实现类中重写call()方法
			
 
				+    3、创建实现类的对象
			
 
				+    4、创建FutureTask对象，把Callable的实现类的对象作为FutureTask类的构造方法的参数
			
 
				+    5、创建Thread类的对象，把FutureTask对象作为Thread类的构造方法的参数
			
 
				+    6、调用Thread对象的start方法，启动线程
			
 
				+    7、再调用Future接口的get方法(实际上就是FutureTask对象的get方法)，获取线程结束后的计算结果。
			
 
				+
			
 
				+线程的方法：
			
 
				+    void setName(String name)   可以将该线程的名称改为name参数
			
 
				+    String getName()        获取线程名称
			
 
				+    Thread currentThread()  获取当前正在执行的线程对象的引用。
			
 
				+
			
 
				+    线程休眠：
			
 
				+        static void sleep(long ms)  让当前的线程停留(暂停执行)指定的毫秒数。
			
 
				+
			
 
				+
			
 
				+线程的生命周期：
			
 
				+    什么是生命周期？ 从生到死的过程。   怎么来滴？怎么没滴？
			
 
				+
			
 
				+线程优先级：
			
 
				+    线程有两种调度方式：
			
 
				+        分时调度模型：所有的线程轮流使用CPU的使用权，平均分配每个线程占用的时间片。
			
 
				+    抢占式调度模型：
			
 
				+        优先让优先级高的线程使用CPU，如果线程的优先级相同，那么就会随机选择一个，
			
 
				+        并且优先级比较高的线程获取的时间片也相对多一些。
			
 
				+ps: java使用的就是抢占式调度模型。
			
 
				+随机性问题：假如计算机只有一个CPU，那么CPU在某一个时刻只能执行一个指令，线程只有得到了时间片才能得到使用权，
			
 
				+才可以执行指令。所以多线程的执行是随机性，也就是谁能抢到执行权是不一定的。
			
 
				+
			
 
				+final int getPriority() 返回线程的优先级
			
 
				+final void setPriority(int newPriority) 修改当前线程的优先级，线程的默认优先级是5，优先级的范围：1~10；
			
 
				+MAX_PRIORITY    10  最高优先级
			
 
				+MIN_PRIORITY    1   最低优先级
			
 
				+
			
 
				+
			
 
				+守护线程
			
 
				+    守护线程随着其他非守护线程的结束而结束。
			
 
				+    设置守护线程的方法：void setDaemon(boolean on)
			
 
				+
			
 
				+卖票问题：
			
 
				+- 案例需求
			
 
				+某电影院目前正在上映国产大片《南京照相馆》，共有100张票，而它有3个窗口卖票，请设计一个程序模拟该电影院卖票
			
 
				+
			
 
				+- 实现步骤
			
 
				+    - 定义一个类SellTicket实现Runnable接口，里面定义一个成员变量：private int tickets = 100;
			
 
				+    - 在SellTicket类中重写run()方法实现卖票，代码步骤如下
			
 
				+    - 判断票数大于0，就卖票，并告知是哪个窗口卖的，卖1张票前，sleep(1)，模拟出票过程。
			
 
				+    - 卖了票之后，总票数要减1
			
 
				+    - 票卖没了，线程停止
			
 
				+    - 定义一个测试类SellTicketDemo，里面有main方法，代码步骤如下
			
 
				+    - 创建SellTicket类的对象
			
 
				+    - 创建三个Thread类的对象，把SellTicket对象作为构造方法的参数，并给出对应的窗口名称
			
 
				+    - 启动线程
			
 
				+
			
 
				+卖票出现了问题：
			
 
				+    1、相同的票出现了多次
			
 
				+    2、出现了负数票
			
 
				+原因：为什么出现上面的问题？
			
 
				+    线程执行的随机性导致，在卖票的过程中丢失了CPU的执行权，导致的问题。
			
 
				+
			
 
				+那么就需要解决多个线程的同步问题，保证线程的数据一致性，线程安全。
			
 
				+这种问题称为线程的安全问题:
			
 
				+    1、有多个线程
			
 
				+    2、线程之间的数据是共享的。
			
 
				+    3、有多个线程操作共享数据。
			
 
				+
			
 
				+实现解决安全问题的方式：
			
 
				+    1、把多条语句操作共享数据的代码锁起来。让任何时刻都只有一个线程能执行。
			
 
				+    2、Java提供了同步代码块的方式解决问题
			
 
				+
			
 
				+解决线程安全的方式：
			
 
				+    1、同步代码块 synchronized代码块
			
 
				+    2、同步方法 synchronized修饰的方法
			
 
				+    3、可重入锁(Lock)   ReentrantLock锁
			
 
				+
			
 
				+1、同步代码块：
			
 
				+    synchronized(任意对象){
			
 
				+        多条语句操作共享数据的代码
			
 
				+    }
			
 
				+    synchronized(任意对象)就相当于给代码加锁了，任意对象就可以看成是一个所。
			
 
				+
			
 
				+    好处：解决多线程数据安全的问题。
			
 
				+    弊端：当线程很多的守护，因为每个线程都要判断同步锁，比较耗费资源，会降低程序的执行效率。
			
 
				+
			
 
				+2、同步方法：
			
 
				+    就是把synchronized关键字加到方法上
			
 
				+    格式：
			
 
				+    访问权限修饰符 synchronized 返回值类型 方法名(参数){
			
 
				+        方法体
			
 
				+    }
			
 
				+    同步方法里的锁对象是当前的对象 this
			
 
				+    静态同步方法格式：
			
 
				+    访问权限修饰符 static synchronized 返回值类型 方法名(参数){
			
 
				+        方法体
			
 
				+    }
			
 
				+    静态同步方法锁对象是这个类  类名.class的对象
			
 
				+
			
 
				+同步监视器：
			
 
				+俗称就是锁，代码块中任何一个类的对象都可以当成锁，但是所有的线程必须要共用同一把锁，共用同一个对象
			
 
				+如果是同步方法中，这个锁就是this，也就是方法所属对象，静态同步方法的锁是类本身。
			
 
				+如果是使用同步代码块，恰好使用继承Thread的方式创建线程，那么一定一定不能使用this作为锁。
			
 
				+
			
 
				+3、ReentrantLock锁(可重入锁)
			
 
				+    Lock类本身是一个接口，他有一个实现类ReentrantLock，我们可以创建实现类对象
			
 
				+    包含两个常用的方法：
			
 
				+        获得锁     void lock()
			
 
				+        释放锁     void unlock()
			
 
				+
			
 
				+lock锁和synchronized同步代码块的相同点和不同点
			
 
				+    1、Lock锁是一种显式锁，需要我们手动的开启和关闭，synchronized是隐式锁，出了作用域之后会自动释放。
			
 
				+    2、Lock锁只有代码块锁，synchronized包含代码块锁和方法锁
			
 
				+    3、使用Lock锁，Java虚拟机JVM可以花费更少的时间来调度线程，性能更好，并且具有更高的扩展性。
			
 
				+
			
 
				+死锁：
			
 
				+    线程的死锁是由于两个或多个线程互相持有对方需要的资源，导致这些线程都处在等待状态，不能继续执行。
			
 
				+产生死锁的原因:
			
 
				+    1、资源有限
			
 
				+    2、同步嵌套
			
 
				+需要做的是避免死锁。
			
 
				+出现死锁后并不会出现异常，也不会出现提示，只是所有的线程都在正常运行，只是都没在工作，而是都在被阻塞而已。
			
 
				+所以使用线程同步的时候，一定要避免死锁。
			
 
				+解决方案：
			
 
				+    1、设计专门的算法，原则。
			
 
				+    2、尽量减少同步资源的定义。
			
 
				+    3、尽量避免嵌套同步。
			
 
				+
			
 
				+
			
 
				+List集合的实现类
			
 
				+    ArrayList   LinkedList
			
 
				+Set集合的实现类
			
 
				+    HashSet     TreeSet
			
 
				+Map集合的实现类
			
 
				+    HashMap     TreeMap
			
 
				+以上6个集合实现类都不是线程同步的，都是线程不安全的。
			
 
				+怎么样让以上的集合变为线程安全的？
			
 
				+1、使用synchronized进行二次封装
			
 
				+2、使用可重入锁。
			
 
				+3、使用Collections工具类，该类里有把线程不安全的集合封装成线程安全的集合的方法。
			
 
				+
			
 
				+
			
 
				+题目 1：多线程操作 HashSet 的线程安全问题
			
 
				+需求：
			
 
				+创建 3 个线程，同时向一个 HashSet 中添加 1-100 的整数（每个线程负责不同区间，如线程 1 加 1-33，线程 2 加 34-66，线程 3 加 67-100），观察最终集合大小是否为 100（可能出现重复添加），然后使用 Collections.synchronizedSet () 包装 HashSet，确保线程安全并验证结果。
			
 
				+
			
 
				+题目 2：多线程向 TreeSet 添加元素并排序
			
 
				+需求：
			
 
				+创建 2 个线程，线程 1 向 TreeSet 中添加 10 个随机偶数，线程 2 添加 10 个随机奇数（范围 1-100），所有线程执行完毕后，遍历 TreeSet 输出元素，验证是否自动按自然顺序排序且无重复。
			
 
				+
			
 
				+题目 3：多线程并发查询 HashSet
			
 
				+需求：
			
 
				+创建一个包含 50 个字符串的 HashSet，启动 4 个线程，每个线程循环 100 次随机查询集合中是否包含某个字符串（从集合元素中随机选取），使用同步机制确保查询过程中集合不被修改，统计每个线程的查询成功次数。
			
--- a/javaSE/out/production/javaSE/J20250731/生产者消费者模式.txt
+++ b/javaSE/out/production/javaSE/J20250731/生产者消费者模式.txt
@@ -0,0 +1,75 @@
 
				+Java23种设计模式------生产者消费者模式
			
 
				+生产者消费者模式是个非常经典的多线程协作的设计模式，
			
 
				+生产者消费者模式实际上是包含两类线程：
			
 
				+    一类是生产者，用来生产数据
			
 
				+    一类是消费者，用来消费数据
			
 
				+为了解耦生产者和消费者之间的关系，一般会采用共享的数据区域，就像一个仓库。
			
 
				+生产者生产数据之后，直接放置在共享数据区域种，不需要关心消费者的行为。
			
 
				+消费者只需要从共享区域种获取数据就可以了，不需要关心生产者的行为。
			
 
				+
			
 
				+Object类提供等待线程和唤醒线程的方法：
			
 
				+void wait() 导致当前的线程等待，不限时等待。直到另一个线程调用了该对象的notify()方法或notifyAll()方法
			
 
				+void notify()   唤醒正在等待【对象监视器】(锁)的单个线程
			
 
				+void notifyAll()唤醒等待的所有线程
			
 
				+
			
 
				+案例：
			
 
				+桌子类(Desk)：定义表示包子数量的变量,定义锁对象变量,定义标记桌子上有无包子的变量
			
 
				+生产者类(Cooker)：实现Runnable接口，重写run()方法，设置线程任务
			
 
				+    1.判断是否有包子,决定当前线程是否执行
			
 
				+    2.如果有包子,就进入等待状态,如果没有包子,继续执行,生产包子
			
 
				+    3.生产包子之后,更新桌子上包子状态,唤醒消费者消费包子
			
 
				+消费者类(Foodie)：实现Runnable接口，重写run()方法，设置线程任务
			
 
				+    1.判断是否有包子,决定当前线程是否执行
			
 
				+    2.如果没有包子,就进入等待状态,如果有包子,就消费包子
			
 
				+    3.消费包子后,更新桌子上包子状态,唤醒生产者生产包子
			
 
				+测试类(Demo)：里面有main方法，main方法中的代码步骤如下
			
 
				+    创建生产者线程和消费者线程对象
			
 
				+    分别开启两个线程
			
 
				+
			
 
				+一直使用线程成本比较高，频繁的创建和销毁线程成本比较高？
			
 
				+线程的状态：
			
 
				+    线程创建并启动后，并不是一启动就进入到执行状态，也不是一直处在等待或执行状态。
			
 
				+    线程对象在不同的时期有不同的状态，那么Java线程到底存在几种状态？
			
 
				+
			
 
				+    根据Java提供的线程类Thread的内部枚举类提供的状态划分：
			
 
				+        1、NEW 新建状态
			
 
				+            |-也叫初始状态，开始状态，就是线程刚被的创建，但是没有被启动，还没有调用start方法，
			
 
				+            类似 Thread t=new Thread() 的情况，但是t只是线程对象，不具备线程特征
			
 
				+        2、RUNNABLE 就绪状态 可运行状态
			
 
				+            |-当我们调用了start方法，那么此时线程对象进入到了RUNNABLE状态，才是真正的在JVM进程种创建了一个线程。
			
 
				+            线程一启动并不是立刻就能够执行的，它暂时没有执行权，线程能不能允许，要听CPU的调度。我们把这个中间状态(新建和运行的中间状态)称为可执行状态。
			
 
				+            也就是说当前这个线程具备了可以执行的资格，但是没有真正的执行起来，需要等CPU调度。
			
 
				+        3、BLOCKED   阻塞状态
			
 
				+            |-当一个线程想要获取一个对象锁，但是这个对象锁被其他线程持有，那么当前线程就进入到了BLOCKED状态也就是阻塞状态。
			
 
				+            假如当前线程获取到了对象锁，那么它会重新进入到RUNNABLE状态。
			
 
				+        4、WAITING   无限时等待
			
 
				+            |-一个正在等待的线程状态，就是所谓的等待状态，造成等待状态的原因有两个：
			
 
				+                1、调用了Object类的wait()方法。
			
 
				+                2、调用了Thread类的join()方法。
			
 
				+                处在等待状态的线程，会等待其他线程执行一个特定的操作，
			
 
				+                比如A线程是由于wait方法，导致的等待，它就需要等其他线程调用notify或notifyAll方法才能被唤醒
			
 
				+                比如B线程是由于join()方法导致的等待，那么它就需要等待其他线程结束，才会恢复。
			
 
				+        5、TIMED_WAITING 计时等待
			
 
				+            |-在一个限定的时间内等待的线程状态，也叫限时等待状态。造成限时等待的状态的方式有三种：
			
 
				+                1、Thread.sleep(long ms)     睡眠
			
 
				+                2、Object.wait(long ms)      等待
			
 
				+                3、Thread.join(long ms)      等待
			
 
				+        6、TERMINATED    终止
			
 
				+            |-是一个完全运行完成的线程的状态，所以叫终止状态，结束状态。
			
 
				+    我们可以通过Thread的getState()方法来获取线程当前的状态
			
 
				+
			
 
				+    操作系统--线程的5种状态
			
 
				+        1、新建
			
 
				+        2、就绪
			
 
				+        3、运行
			
 
				+        4、阻塞
			
 
				+        5、终止
			
 
				+    Java的线程6种状态：
			
 
				+        1、新建
			
 
				+        2、可运行
			
 
				+        3、无限时等待
			
 
				+        4、计时等待
			
 
				+        5、阻塞
			
 
				+        6、终止
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250731/线程安全的集合或工具类.txt
+++ b/javaSE/out/production/javaSE/J20250731/线程安全的集合或工具类.txt
@@ -0,0 +1,14 @@
 
				+线程安全的集合或工具类
			
 
				+线程安全的集合：Map系集合
			
 
				+Hashtable类，集合中现在常用的是HashMap集合。
			
 
				+但是HashMap是线程不安全的，多线程环境下进行存取可能会出现问题。
			
 
				+为了保证数据的安全性，我们可以使用Hashtable(但是强烈不建议)，但是Hashtable效率太低。
			
 
				+
			
 
				+ConcurrentHashMap 集合类，
			
 
				+    1、HashMap常用，但线程不安全
			
 
				+    2、Hashtable线程安全，但效率太低。
			
 
				+所以JDK1.5之后出现了ConcurrentHashMap。
			
 
				+
			
 
				+    HashMap效率高，但线程不安全，多线程环境下会出现数据安全问题
			
 
				+    Hashtable线程安全，但会将整张表全部锁起来，效率太低。
			
 
				+    ConcurrentHashMap也是线程安全的，但是效率比Hashtable高很多。
			
--- a/javaSE/out/production/javaSE/J20250731/线程池.txt
+++ b/javaSE/out/production/javaSE/J20250731/线程池.txt
@@ -0,0 +1,52 @@
 
				+线程池
			
 
				+线程池可以理解为是一个池子，里面存储多个线程。
			
 
				+线程池在启动的时候，会创建大量的空闲线程，当我们向线程池提交任务的时候
			
 
				+线程池就会启动一个线程来处理任务。等任务处理完毕后，线程不会死亡，
			
 
				+而是再次返回到线程池中，成为空闲状态，等待执行下一次任务。
			
 
				+线程池设计思路：
			
 
				+1、准备一个任务容器
			
 
				+2、一次性启动多个消费者线程
			
 
				+3、刚开始任务容器是空的，所以所有消费者线程都是wait()等待状态
			
 
				+4、直到一个外部线程(生产者)向这个任务容器扔了一个任务，就会有一个消费者线程被唤醒。
			
 
				+5、这个消费者线程取出任务，并且执行这个任务，执行完毕后，会再次进入等待状态，继续等待下一个任务。
			
 
				+
			
 
				+Java为我们提供了很多的线程池：
			
 
				+ExecutorService newCachedThreadPool();方法创建一个默认的线程池
			
 
				+ExecutorService newFixedThreadPool(int nThreads)    创建一个线程池，指定核心线程数和最大线程数
			
 
				+刚开始创建线程池的时候，并不会自动的创建线程放进线程池，直到有任务需要线程执行，才会创建线程来执行任务。
			
 
				+
			
 
				+ThreadPoolExecutor 这个线程池对象我们用的更多一些
			
 
				+ThreadPoolExecutor pool=new ThreadPoolExecutor(核心线程数，最大线程数，空闲线程最大存活时间，时间单位，任务队列，线程工厂，任务拒绝策略)
			
 
				+    1、核心线程数     -->不能小于0
			
 
				+    2、最大线程数     -->不能小于等于0，最大线程数必须大于或等于核心线程数
			
 
				+    3、空闲线程最大存活时间    -->不能小于0
			
 
				+    4、时间单位      -->时间单位
			
 
				+    5、任务队列      -->不能为null
			
 
				+    6、线程工厂      -->不能为null
			
 
				+    7、任务拒绝策略    -->不能为null
			
 
				+
			
 
				+线程池的任务拒绝策略：
			
 
				+    1、ThreadPoolExecutor.AbortPolicy类 默认的拒绝策略，丢掉任务，并且抛出RejectedExecutionException异常
			
 
				+    2、ThreadPoolExecutor.DiscardPolicy类 丢弃任务，但是不抛出任何异常， 不建议使用。
			
 
				+    3、ThreadPoolExecutor.DiscardOldestPolicy    丢弃队列中等待最久的任务，然后把当前的任务加入到队列。
			
 
				+    4、ThreadPoolExecutor.CallerRunsPolicy   调用任务的run()方法，绕过线程池直接运行。
			
 
				+
			
 
				+ThreadPoolExecutor pool = new ThreadPoolExecutor(
			
 
				+                2,
			
 
				+                5,
			
 
				+                20,
			
 
				+                TimeUnit.MICROSECONDS,
			
 
				+                new ArrayBlockingQueue<>(10),
			
 
				+                Executors.defaultThreadFactory(),
			
 
				+                new ThreadPoolExecutor.DiscardPolicy());    //设置拒绝策略
			
 
				+
			
 
				+线程池最多可以执行的任务数=任务队列的容量+最大线程数
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250801/练习题.txt
+++ b/javaSE/out/production/javaSE/J20250801/练习题.txt
@@ -0,0 +1,10 @@
 
				+题目1：批量数据导入-线程池
			
 
				+后台系统需要将10万条Excel数据导入到数据库，
			
 
				+单条数据插入的耗时5ms，如果一条一条的同步插入，需要500秒，大约8分钟左右。
			
 
				+需要使用线程池进行并发提速，同时避免数据库连接耗尽。
			
 
				+需求：
			
 
				+    1、创建核心线程数10，最大线程数20，工作队列容量1000的线程池(ThreadPoolExecutor)
			
 
				+空闲线程存活时间30秒。
			
 
				+    2、每个任务负责导入100条数据(模拟耗时500ms)，打印"批次[x]导入完成，成功[x]条"。
			
 
				+    3、提交1000个导入任务，一共10万条数据，统计总耗时
			
 
				+    4、所有任务完成后关闭线程池，打印"全部数据导入完成"。
			
--- a/javaSE/out/production/javaSE/J20250802/原子性.txt
+++ b/javaSE/out/production/javaSE/J20250802/原子性.txt
@@ -0,0 +1,105 @@
 
				+关键字-volatile
			
 
				+volatile是Java提供的一种轻量级的同步机制，Java中包含两种同步机制：
			
 
				+    |-同步方法、同步代码块 synchronized一般被称为重量级锁
			
 
				+    |-volatile变量，更轻量级，属于轻量级锁。因为它不会引起线程上下文的切换和调度。但是volatile变量的同步性比较差。也更容易出错。
			
 
				+作用：强制线程每次在使用的时候，都会看到共享区域的最新值
			
 
				+
			
 
				+原子性：
			
 
				+    原子性其实是Java并发变成的多个概念之一，
			
 
				+    一次操作或多次操作中，要么所有的操作全部都得到了执行，并且不受到任何因素的干扰而中断。
			
 
				+    要么所有的操作都不执行，多个操作步骤是一个不能分割的整体。
			
 
				+    原子性就是拒绝多线程的，不论是单核还是多核，只要是具备原子性的量。同一时刻只能有一个线程对他进行操作。
			
 
				+    整个操作过程中，不会被线程调度器中断的操作，都可以认为是具有原子性的。
			
 
				+    比如：a=1，就是具有原子性的，a++或a+=1或a=a+1 他就不是原子性的操作。
			
 
				+    Java中的原子性操作：
			
 
				+        1、基本数据类型的读取和赋值操作，并且赋值必须是值给变量，变量之间的相互赋值就不属于原子性操作。
			
 
				+        2、Java中提供了一个包，整个包里面所有的类都属于原子性操作:java.util.concurrent.atomic
			
 
				+可见性：
			
 
				+    指的是当多个线程访问同一个变量的时候，一个线程改变了这个变量的值，其他线程能够立即看到修改的值。
			
 
				+    在多线程环境下啊，一个线程对共享变量进行了操作对于其他线程是不可见的，Java提供了volatile来保证共享变量的可见性。
			
 
				+    当一个变量被volatile修饰之后，表示线程的本地内存无效，当一个线程修改了共享变量之后它会立刻被更新到主内存中，
			
 
				+    其他的线程读取共享变量的时候，就可以直接到主内存读取。
			
 
				+    synchronized和Lock也可以保证共享变量的可见性。因为synchronized和Lock是保证同一时刻只有一个线程能够获取锁，
			
 
				+    并且执行同步代码，并且在释放锁之前会对变量的修改进行刷新，刷新到主内存中，所以才能保证可见性。
			
 
				+
			
 
				+volatile：
			
 
				+    能够保证可见性，但是不能保证原子性。
			
 
				+    当我们定义了一个volatile修饰的变量后，虚拟机会把这个线程的本地内存中变量强制的刷新到主内存中。
			
 
				+    这个线程的写操作就会导致其他线程的volatile变量缓存无效。而是直接去主内存找变量。
			
 
				+volatile不能保证原子性。我们可以加锁，加锁之后，同一时间只能被一个线程执行，这种数据我们成为临界区数据，操作它的代码就称为临界区代码。
			
 
				+这样count++就成了原子操作。
			
 
				+
			
 
				+原子性类：AtomicInteger
			
 
				+AtomicInteger是从JDK1.5开始提供的java.util.concurrent.atomic里一个类，这个包里面的原子操作类提供了一种方法：
			
 
				+可以比较高效的，简单的更新一个变量的方式。
			
 
				+atomic里面提供了13种类，属于4种类型的原子更新方式，分别是：
			
 
				+    原子更新基本数据类型
			
 
				+    原子更新数组
			
 
				+    原子更新引用
			
 
				+    原子更新属性
			
 
				+原子更新基本数据类型：
			
 
				+    AtomicInteger   原子更新整数类型
			
 
				+    AtomicBoolean   原子更新布尔类型
			
 
				+    AtomicLong      源自更新长整数类型
			
 
				+以AtomicInteger类型举例：
			
 
				+    构造方法：
			
 
				+        无参构造：new AtomicInteger()    初始化一个默认值(0)的原子类型Integer
			
 
				+        有参构造：new AtomicInteger(int v)   初始化一个指定参数的原子类型Integer
			
 
				+    普通方法：
			
 
				+        int get() 获取值
			
 
				+        int incrementAndGet() 以原子方式将当前的值+1，返回的是自增后的值
			
 
				+        int addAndGet(int delta)    以原子方式将参数添加到值。以原子的方式将输入的值和对象中值相加，得到最后的结果。
			
 
				+        int getAndSet(int value)     以原子方式设置为新的value值，并且把旧的值返回
			
 
				+
			
 
				+AtomicInteger的内存分析以及基本原理
			
 
				+AtomicInteger原理是自旋锁+CAS算法
			
 
				+
			
 
				+CAS算法全称是Compare And Swap 也就是 比较和交换。
			
 
				+算法公式 CAS(V,E,N)
			
 
				+    V：表示要更新的变量
			
 
				+    E：表示预期的值
			
 
				+    N：表示新值
			
 
				+
			
 
				+如果V值等于E值，就把V的值设置为N，如果V值不等于E值，就说名已经有了其他线程完成了更新。
			
 
				+那么当前线程就什么都不做。就是CAS需要我们提供一个期望值，当期望值和当前线程的变量值相同，
			
 
				+说明还没有线程修改这个值，那么当前线程就可以进行修改，也就是执行CAS操作，如果期望值和
			
 
				+当前线程不符，说明这个值已经被其他线程修啊给i了，这个时候就不执行更新操作了，但是可以
			
 
				+重新选择读取这个变量，再次尝试修改这个变量，或者干脆放弃操作。
			
 
				+
			
 
				+有3个操作数，内存的值V，表示要更新的变量。 旧的预期值E。要修改的值N
			
 
				+如果旧的预期值E==内存值V，表示修改成功，就是把V改为N
			
 
				+如果旧的预期值E!=内存值V，表示修改失败，不做任何操作。
			
 
				+并且重新获取现在的最新值，这个重新获取的动作就是【自旋】
			
 
				+
			
 
				+乐观锁：CAS是从乐观状态的角度出发，它认为每次获取数据，别人都没有修改过，那么它就可以直接修改共享数据的值。
			
 
				+        CAS不会上锁，只会在修改共享数据之前，检查一些别人有没有修改这个数据。
			
 
				+悲观锁：synchronized是一个悲观锁的状态，总是从最坏的角度出发，认为每次获取数据的时候，别人都有可能修改了数据，所以每次操作共享数据之前，都会上锁。
			
 
				+CAS和synchronized相同点，都可以保证共享数据的安全性。
			
 
				+不同点：CAS是乐观锁，synchronized是悲观锁。
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250805/反射.txt
+++ b/javaSE/out/production/javaSE/J20250805/反射.txt
@@ -0,0 +1,52 @@
 
				+反射机制：
			
 
				+是在运行状态中对任意一个类，都能直到这个类的【所有属性和方法】。
			
 
				+对于任何一个对象，都能够调用它的任意的属性和方法。
			
 
				+这种动态获取信息以及动态调用对象方法的功能称为：Java语言的反射机制
			
 
				+
			
 
				+Class类--代表所有类的类型
			
 
				+获取Class类的方式：
			
 
				+    1、类名.class属性
			
 
				+    2、对象名.getClass()方法
			
 
				+    3、Class.forName(全限定类名)方法
			
 
				+方法：
			
 
				+获取某个类的所有【公共的】构造方法组成的数组  getConstructors()
			
 
				+获取某个类的所有的构造方法组成的数组          getDeclaredConstructors()
			
 
				+获取某个公共构造方法的对象       getConstructor()
			
 
				+获取某个构造方法的对象         getDeclaredConstructor()
			
 
				+Constructor--代表所有的构造方法的类型
			
 
				+
			
 
				+
			
 
				+Field--代表所有的成员变量的类型
			
 
				+
			
 
				+
			
 
				+Method---代表所有方法的类型
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250805/枚举.txt
+++ b/javaSE/out/production/javaSE/J20250805/枚举.txt
@@ -0,0 +1,51 @@
 
				+枚举
			
 
				+为了间接的表示一些固定的值，Java提供了枚举类
			
 
				+将变量的值一个一个的列出来，变量的值只限于列举出来的范围内。
			
 
				+
			
 
				+枚举也是引用变量的一种
			
 
				+    类
			
 
				+    数组
			
 
				+    接口
			
 
				+    枚举
			
 
				+    注解
			
 
				+格式：
			
 
				+    public enum 类名{
			
 
				+        枚举项1,枚举项2,枚举项3,...,枚举项n;
			
 
				+        定义枚举类必须是enum关键字
			
 
				+    }
			
 
				+
			
 
				+枚举的特点：
			
 
				+    1、所有的枚举类都有一个共同的父类Enum类
			
 
				+    2、我们可以通过"枚举类名.枚举项名"方式去访问指定的枚举项
			
 
				+    3、每个枚举项其实就是这个枚举类的一个对象。
			
 
				+    4、枚举也是一个类，也可以定义成员变量
			
 
				+    5、枚举类的第一行必须是枚举项，最后一个枚举项后面是以分号结尾。如果枚举类中除了枚举项之外没有其他成员，则分号可以省略。
			
 
				+    6、枚举类也可以有构造方法，但是必须是private的，默认也是private的
			
 
				+    7、枚举类也可以有抽象方法，但是枚举项必须要重新这个抽象方法。
			
 
				+
			
 
				+枚举的方法：
			
 
				+String name()   获取枚举项的名称
			
 
				+int ordinal()   获取枚举项的索引值
			
 
				+int compareTo(E o)  比较两个枚举项，返回枚举项的差值
			
 
				+String toString() 返回枚举常量的名称
			
 
				+values()    获取所有的枚举项
			
 
				+static<T> T valueOf(Class<T> type,String name) 获取指定枚举类中的指定名称的枚举值
			
 
				+
			
 
				+案例1：
			
 
				+定义一个星期的枚举Week，包含星期一(MONDAY)到星期日(SUNDAY)。
			
 
				+编写程序：
			
 
				+    1、遍历枚举所有成员并打印
			
 
				+    2、判断输入的字符串，比如MONDAY，是否为工作日周一-周五。
			
 
				+
			
 
				+案例2：
			
 
				+定义一个表示季节的枚举Season，包含SPRING SUMMER AUTUMN WINTER
			
 
				+每个枚举成员需要包含两个属性：季节名称(中文)和平均温度(整数)
			
 
				+需要实现的方法：
			
 
				+    getChineseName() 返回该枚举项的中文名称
			
 
				+    getAvgTemperature() 返回平均温度
			
 
				+    编写测试代码，打印每个季节的中文名称和平均温度。
			
 
				+
			
 
				+案例3
			
 
				+定义一个接口Operation 包含方法 int calculate(int a,int b)。
			
 
				+定义枚举类ArithmeticOperation类实现Operation接口，包含加、减、乘、除四个枚举项。
			
 
				+实现每个枚举项的计算方法，完成对应的运算，如果进行除法运算时，如果除数为0，则抛出异常。
			
--- a/javaSE/out/production/javaSE/J20250805/类加载器.txt
+++ b/javaSE/out/production/javaSE/J20250805/类加载器.txt
@@ -0,0 +1,61 @@
 
				+类加载器
			
 
				+类的加载过程：
			
 
				+Java文件--->Class文件(字节码文件)--->虚拟机进行解释
			
 
				+
			
 
				+加载类的时机：
			
 
				+1、创建类的对象
			
 
				+2、调用类的类方法
			
 
				+3、访问类或接口的类变量或为类变量赋值
			
 
				+4、使用反射方式来强制创建某个类或接口的Class对象
			
 
				+5、初始化某个类的子类
			
 
				+6、直接使用java.exe命令来运行某个类
			
 
				+
			
 
				+其实就是只要实用了这个类或这个类的成员或者这类的子类，这时候就会加载这个类到虚拟机
			
 
				+
			
 
				+类的加载过程：
			
 
				+1、通过一个类的全限定名(包名.类名)获取定义这个类的二进制字节流。
			
 
				+2、把这个字节流的静态存储结构转换为运行时数据结构
			
 
				+3、在内存中生成一个代表这个类的java.lang.Class对象，任何类在被使用的时候，系统都会创建他的java.lang.Class对象
			
 
				+
			
 
				+类的加载过程：
			
 
				+    1、加载
			
 
				+        |-通过包名.类名，找到这个类，并且准备使用流进行传输
			
 
				+        |-就是把这个类加载到内存中，当加载完毕之后，就会创建一个Class对象
			
 
				+    2、链接
			
 
				+        |-1、验证
			
 
				+            验证阶段是链接阶段的第一步
			
 
				+            保证Class文件的字节流中包含的信息能够符合当前虚拟机的需求
			
 
				+            检查文件中的信息是不是符合虚拟机的规范，有没有安全隐患
			
 
				+        |-2、准备
			
 
				+            负责将类的类变量(static修饰的)分配内存，并且设置默认的初始化值。
			
 
				+        |-3、解析
			
 
				+            把类的二进制数据流中的符号引用替换为直接引用。
			
 
				+            如果当前类中引用了其他类，这个时候就需要找到对应的类。
			
 
				+    3、初始化
			
 
				+        根据我们通过程序指定的主管计划进行初始化类变量和其他的资源，
			
 
				+        比如进行静态变量赋值，或者进行其他的初始化资源
			
 
				+类的加载过程：
			
 
				+1、把Student.java文件编译成Student.class文件字节码文件
			
 
				+2、拿到了字节码文件后，开始进入到【加载】阶段，通过包名.类名获取这个类。
			
 
				+并且把这个类加载到内存中。加载完成后创建一个Class对象。
			
 
				+3、进入【链接】阶段，链接阶段主要做3件事：验证、准备、初始化。
			
 
				+	验证：检查一下
			
 
				+	准备：提前把需要加载的类的静态变量这种先加载，并初始化默认值。
			
 
				+	解析：把符号引用替换为直接引用。
			
 
				+4、进入到【初始化】阶段：完成初始化工作，比如对静态变量进行赋值
			
 
				+
			
 
				+类的加载器分类：
			
 
				+    BootstrapClassLoader:Java虚拟机内置的类加载器，一般表示为null，并且没有父null。
			
 
				+    PlatformClassLoader:平台类加载器，负责加载JDK中的一些特殊的模块
			
 
				+    SystemClassLoader:系统类加载器，负责加载用户的类路径上指定的类库。
			
 
				+
			
 
				+继承关系：
			
 
				+    SystemClassLoader的父加载器是PlatformClassLoader，
			
 
				+    PlatformClassLoader的父加载器是BootstrapClassLoader
			
 
				+
			
 
				+双亲委派模型
			
 
				+    如果一个类加载器收到了类加载请求，它绝不会自己先去加载，而是把这个请求委托给父类的加载器去执行。
			
 
				+    如果父类的加载器还存在父类加载器，就会再次向上委托，依次递归，直到请求最终到达最顶层的启动类加载器。
			
 
				+    如果父类加载器可以完成类加载任务，就成功返回。如果父类加载器不能完成任务，子类加载器才会尝试自己加载，
			
 
				+    这就是双亲委派模式。
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250806/反射.txt
+++ b/javaSE/out/production/javaSE/J20250806/反射.txt
@@ -0,0 +1,74 @@
 
				+反射-Class的方法：
			
 
				+反射-Class获取成员构造方法：
			
 
				+    获取某个类的所有【公共的】构造方法组成的数组  getConstructors()
			
 
				+    获取某个类的所有的构造方法组成的数组          getDeclaredConstructors()
			
 
				+    获取某个公共构造方法的对象       getConstructor()
			
 
				+    获取某个构造方法的对象         getDeclaredConstructor()
			
 
				+反射-Class获取成员变量对象：
			
 
				+    返回所有公共成员变量对象的数组 Field[] getFields();
			
 
				+    返回所有成员变量对象的数组   Field[] getDeclaredFields();
			
 
				+    返回单个公共成员变量对象    Field getField(String name);
			
 
				+    返回单个成员变量对象    Field getDeclaredField(String name);
			
 
				+反射-Class获取父类和接口的方法：
			
 
				+    返回某个类的所有父类 getSuperclass();
			
 
				+    返回某个类的所有实现的接口 getInterface();
			
 
				+反射-Class获取方法的方法：
			
 
				+    返回所有的公共方法--包含从父类继承的方法 Method[] getMethods();
			
 
				+    返回所有的方法 Method[] getDeclaredMethods();
			
 
				+    返回单个公共的成员方法对象  Method getMethod(String name, Class<?>... parameterTypes)
			
 
				+    name是方法名，parameterTypes是参数类型列表
			
 
				+    返回单个成员方法对象  Method getDeclaredMethod(String name, Class<?>... parameterTypes)
			
 
				+
			
 
				+
			
 
				+Constructor--代表所有的构造方法的类型
			
 
				+    根据指定的构造方法创建对象   T newInstance(Object..initargs)
			
 
				+    设置为true，表示取消访问检查    setAccessible(boolean flag)
			
 
				+    获取构造方法的参数类型  getParameterTypes()
			
 
				+    获取构造方法的修饰符      getModifiers()
			
 
				+    获取构造方法参数的个数   getParameterCount()
			
 
				+
			
 
				+Field--代表所有的成员变量的类型
			
 
				+反射-Field的方法：
			
 
				+    赋值  void set(Object obj,Object value)
			
 
				+    取值  Object get(Object obj)
			
 
				+    获取这个成员变量的类型 getType()
			
 
				+    获取这个成员变量的修饰符    getModifiers()
			
 
				+
			
 
				+Method---代表所有方法的类型
			
 
				+反射-Method的方法：
			
 
				+    调用指定对象的方法   invoke(Object obj,Object...args);
			
 
				+    获取方法的返回值类型  getReturnType()
			
 
				+    获取方法的参数类型列表 getParameterTypes()
			
 
				+    获取这个成员方法的修饰符    getModifiers()
			
 
				+
			
 
				+案例1：基础类信息获取
			
 
				+编写程序，使用反射获取java.lang.String类的以下信息并打印：
			
 
				+类的全限定名
			
 
				+所有实现的接口
			
 
				+父类
			
 
				+访问修饰符
			
 
				+
			
 
				+案例2：构造方法调用
			
 
				+    定义一个包含私有构造方法（接收String参数）和公共无参构造方法的Person类，
			
 
				+    使用反射分别创建这两种构造方法对应的实例对象。
			
 
				+案例3：字段操作
			
 
				+    创建一个Student类，包含私有字段name和age，以及公共字段id。使用反射完成：
			
 
				+    获取所有字段（包括私有）并打印名称和类型
			
 
				+    修改私有字段age的值
			
 
				+    读取私有字段name的值
			
 
				+
			
 
				+案例4：方法调用
			
 
				+    在Calculator类中定义：
			
 
				+    公共方法add(int a, int b)返回两数之和
			
 
				+    私有方法multiply(double a, double b)返回两数之积
			
 
				+    使用反射调用这两个方法并输出结果。
			
 
				+
			
 
				+案例5：反射综合应用
			
 
				+    编写一个通用的对象转 Map 工具类ObjectToMapConverter，使用反射实现：
			
 
				+    接收任意对象作为参数
			
 
				+    将对象的所有非静态字段名作为 key，字段值作为 value 存入Map
			
 
				+    支持忽略指定字段（如通过参数String... ignoreFields）
			
 
				+
			
 
				+public Map toMap(Object obj,String... ignoreFields){
			
 
				+
			
 
				+}
			
--- a/javaSE/out/production/javaSE/J20250806/注解.txt
+++ b/javaSE/out/production/javaSE/J20250806/注解.txt
@@ -0,0 +1,51 @@
 
				+注解
			
 
				+Java注解，也叫Java标注。对程序进行标注和解释，让虚拟机能够根据注解进行编译期验证。
			
 
				+注释：是给程序员看的
			
 
				+注解：是给虚拟机看的
			
 
				+使用注解的优势：
			
 
				+代码更加简洁，而且方便
			
 
				+Java中常用的注解：
			
 
				+@Override   检查这个方法是不是重写的方法，如果发现父类或接口没有这个方法，则报错。
			
 
				+
			
 
				+自定义注解：
			
 
				+格式：
			
 
				+public @interface 注解名{
			
 
				+    public 属性类型 属性名() default 默认值;
			
 
				+}
			
 
				+其中属性类型可以是：
			
 
				+    基本数据类型、String、Class、注解、枚举，包括这些类型的一维数组都可以
			
 
				+
			
 
				+如果注解中的属性只有一个，并且属性名是value，那么我们在使用注解的时候可以不指定value属性，而是直接赋值。
			
 
				+@interface MyAnno02{
			
 
				+    String value();
			
 
				+}
			
 
				+@MyAnno02("呵呵呵呵呵呵")
			
 
				+public class Demo01 {
			
 
				+
			
 
				+}
			
 
				+
			
 
				+案例：
			
 
				+需求：使用一个注解@MyTest，用在指定的类的方法上，如果某一个类的方法使用了这个注解，
			
 
				+那么就执行这个方法。
			
 
				+实现步骤：
			
 
				+    1、自定义一个注解@MyTest，并且在类中的某几个方法上添加这个注解
			
 
				+    2、在测试类中，获取注解所在的类的Class对象
			
 
				+    3、获取类的所有的方法对象
			
 
				+    4、遍历每一个方法对象，判断有没有对应的注解。
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250807/代理模式.txt
+++ b/javaSE/out/production/javaSE/J20250807/代理模式.txt
@@ -0,0 +1,98 @@
 
				+代理模式
			
 
				+    代理模式(Proxy Pattern)是Java中常用的一种设计模式。它属于【结构型】模式。
			
 
				+1、代理模式的核心思想：
			
 
				+    通过一个"代理对象"来代替"真实对象"，通过这种方式来控制对"真实对象"的访问。
			
 
				+    说人话，代理模式中代理，就是代理人，中介。
			
 
				+    代理模式就像中介、代购、经纪人。比如想租房，不需要直接找房东(真实对象)，
			
 
				+    而是找中介(代理对象)。中介会帮你联系房东，还能额外提供看房、签合同等等服务。
			
 
				+2、代理模式的核心特点：
			
 
				+    1、【代理类和真实类实现相同的接口，或者继承相同的父类】，保证代理对象和真实对象都能
			
 
				+    被统一使用，比如房东可以令你看房，中介也可以领你看房。
			
 
				+    2、【代理类持有真实对象的引用，可以直接调用真实对象的方法】，比如：中介手里有房东的联系方式，
			
 
				+    能够让房东最终交房。
			
 
				+    3、【代理类可以在调用真实对象的方法前后，添加额外的操作】。比如：中介要在签合同之前核实你的身份，
			
 
				+    签完合同要给中介费。
			
 
				+3、为什么需要代理模式？
			
 
				+代理模式的核心价值其实就是"控制访问"和"增强功能"：
			
 
				+    1、保护真实对象，比如限制只有管理员才能访问某一个敏感对象
			
 
				+    2、增强功能：在不修改真实对象的代码的前提下，添加一些功能，日志、权限校验、缓存等等功能
			
 
				+    3、远程访问：通过代理模式访问远端服务器里面的对象
			
 
				+4、代理模式的分类：
			
 
				+    静态代理
			
 
				+    动态代理
			
 
				+    两种代理方式核心逻辑是一样的， 但是实现的方式和使用的场景不一样。
			
 
				+--------------------------------------------------------------
			
 
				+静态代理(static proxy)
			
 
				+    静态代理就是在编译期就已经确定了代理类的代码， 需要我们手动写代理类。
			
 
				+实现步骤：租房
			
 
				+    1、定义接口(代表代理类和真实类有共同的行为)
			
 
				+    接口，其实就是代理类和真实类的"约定"，确保两个类能够被统一调用，
			
 
				+    创建一个Rent接口，包含租房方法。
			
 
				+    2、实现真实类---被代理的对象
			
 
				+    就是房东，是最终提供服务的对象，需要实现Rent接口
			
 
				+    3、实现代理类---中介
			
 
				+        |-实现Rent接口，保证行为和真实类一致。
			
 
				+        |-持有真实类的引用，可以通过构造传入。
			
 
				+        |-在调用真实类的方法的前后，添加额外的操作，比如中介的服务
			
 
				+静态代理的优缺点：
			
 
				+    优点：
			
 
				+        简单、直观、代码好理解、不需要依赖复杂的框架。
			
 
				+    缺点：
			
 
				+        当接口新增方法，代理类和真实类都需要修改。
			
 
				+        有多少个真实类，就得有多少个代理类
			
 
				+
			
 
				+动态代理(Dynamic Proxy)
			
 
				+    动态代理是在程序运行时，通过反射动态生成代理类的代码，不需要我们手动编写代理类。
			
 
				+    解决了静态代理的每个真实类都要手写一个代理类的情况，适合批量处理多个类的场景。
			
 
				+    Java中常用的动态代理有两种：
			
 
				+        JDK动态代理，基于接口的。
			
 
				+        CGLIB动态代理，基于继承的。
			
 
				+1、JDK动态代理是Java官方提供的，java.lang.reflect包里，要求被代理的类必须要实现接口。
			
 
				+以给所有的方法添加日志，作为例子：
			
 
				+实现步骤：
			
 
				+    1、定义接口(比如：UserService)和真实类(实现类：UserServiceImpl)
			
 
				+    2、实现InvocationHandler接口，里面是代理逻辑
			
 
				+        JDK动态代理需要一个"调用处理程序|调用处理器"，实现InvocationHandler接口，
			
 
				+        用来定义代理类的额外操作，比如日志。
			
 
				+        InvocationHandler接口里只有一个抽象方法：
			
 
				+        Object invoke(Object proxy, Method method, Object[] args)throws Throwable;
			
 
				+        包含参数：
			
 
				+            proxy：动态生成的奥地利对象，一般我们是不用的
			
 
				+            method：当前调用的方法，比如addUser、deleteUser
			
 
				+            args：方法的参数列表，比如addUser的参数。
			
 
				+        我们既然要使用JDK动态代理实现为每个方法添加日志，就要创建一个日志处理类
			
 
				+    3、生成代理对象，并且进行测试
			
 
				+    通过Proxy.newProxyInstance()方法动态的生成代理对象。
			
 
				+    newProxyInstance()方法需要传入3个参数：
			
 
				+        |-ClassLoader loader    真实类的类加载器 target.getClass().getClassLoader();
			
 
				+        |-Class<?>[] interfaces 真实类实现的接口 target.getClass().getInterfaces();
			
 
				+        |-InvocationHandler h   调用处理器，比如我们自己创建的日志处理器LogHandler
			
 
				+JDK动态代理只能代理"实现了某个接口的类"，如果某个类没有接口，那么就代理不了。这时候就需要CGLIB动态代理
			
 
				+
			
 
				+CGLIB动态代理，基于继承的。
			
 
				+CGLIB动态代理是一个第三方库，是通过继承被代理类生成代理子类，所以被代理类不能是final修饰的，否则就无法继承，不能代理。
			
 
				+实现步骤：
			
 
				+    0、先导入CGLIB依赖库。
			
 
				+    1、定义没有接口的真实类，假如某个类没有实现任何接口
			
 
				+    2、实现MethodInterceptor接口--处理代理逻辑
			
 
				+        CGLIB动态代理是使用MethodInterceptor接口定义代理的额外操作，核心的方法是intercept()方法
			
 
				+        intercept()方法包含4个参数：
			
 
				+        Object obj          代理对象，子类实例
			
 
				+        java.lang.reflect.Method method  当前调用的方法
			
 
				+        Object[] args   方法的参数
			
 
				+        MethodProxy proxy   方法的代理对象(用来调用父类的方法)
			
 
				+    3、生成代理类对象并且进行测试,过增强器对象Enhancer，生成代理类
			
 
				+
			
 
				+动态代理的优缺点：
			
 
				+    优点：不需要手动编写代理类、可以批量处理多个类，比如给所以方法统一添加日志，灵活性很高。
			
 
				+    缺点：逻辑相比静态代理要复杂一些，理解难度也高一些。
			
 
				+    JDK动态代理只能代理接口及其实现类。CGLIB需要依赖第三方库，而且不能代理final类。
			
 
				+
			
 
				+使用代理模式的场景：
			
 
				+    Spring AOP面向切面编程，核心就是动态代理。
			
 
				+    日志框架，通过代理模式给所有的方法都自动添加日志输出
			
 
				+    权限控制，每当调用一些敏感方法之前，都是通过代理验证用户的权限。
			
 
				+    缓存，在调用方法之前，可以通过代理检查缓存，避免重复计算。
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250807/注解.txt
+++ b/javaSE/out/production/javaSE/J20250807/注解.txt
@@ -0,0 +1,29 @@
 
				+元注解：
			
 
				+    元注解其实就是描述注解的注解。
			
 
				+常用的元注解：
			
 
				+    @Retention  理解它修饰的哪个注解可以保留的时间(生命周期)，保留策略。
			
 
				+        |-它有三个值：SOURCE(编译的时候就丢掉),CLASS(跟着类走),RUNTIME(一直保留到程序运行时)
			
 
				+    @Target 指定了注解能够在哪使用
			
 
				+        |-ElementType.TYPE      类、接口、枚举类
			
 
				+        |-ElementType.FIELD 属性、成员变量
			
 
				+        |-ElementType.METHOD    方法
			
 
				+        |-ElementType.PARAMETER 参数
			
 
				+        |-ElementType.CONSTRUCTOR   构造方法
			
 
				+        |-ElementType.LOCAL_VARIABLE    局部遍历
			
 
				+        |-ElementType.ANNOTATION_TYPE   注解类型
			
 
				+        |-ElementType.PACKAGE   包
			
 
				+        |-ElementType.TYPE_PARAMETER    参数类型
			
 
				+        |-ElementType.TYPE_USE  使用类型
			
 
				+    @Documented 表示该自定义注解，会出现在API文档里面。
			
 
				+    @Inherited  表示修饰的自定义注解可以被子类继承
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/out/production/javaSE/J20250808/时间日期类JDK8.txt
+++ b/javaSE/out/production/javaSE/J20250808/时间日期类JDK8.txt
@@ -0,0 +1,52 @@
 
				+Java8后新增的时间和日期类：
			
 
				+LocalDate   表示日期-年月日
			
 
				+LocalTime   表示时间-时分秒
			
 
				+LocalDateTime   表示日期时间-年月日时分秒
			
 
				+
			
 
				+LocalDateTime类的创建方式
			
 
				+获取当前系统的时间   public static LocalDateTime now()
			
 
				+使用指定年月日时分秒初始化一个LocalDateTime对象
			
 
				+    public static LocalDateTime of(年,月,日,时,分,秒)
			
 
				+
			
 
				+获取年 int getYear()
			
 
				+获取月份1-12   int getMonthValue()
			
 
				+获取月份中的第几天 1~31  int getDayOfMonth()
			
 
				+获取一年中的第几天 1~366 int getDayOfYear()
			
 
				+获取星期    DayOfWeek getDayOfWeek()
			
 
				+获取小时    getHour()
			
 
				+获取分钟    getMinute()
			
 
				+获取秒     getSecond()
			
 
				+
			
 
				+LocalDateTime转换方法
			
 
				+转换为一个LocalDate对象    toLocalDate()
			
 
				+转换为一个LocalTime对象    toLocalTime()
			
 
				+
			
 
				+格式化方法：
			
 
				+把一个LocalDateTime对象格式化为一个字符串
			
 
				+    String format(指定的格式)
			
 
				+把一个日期字符串解析成一个LocalDateTime对象
			
 
				+    LocalDateTime parse(要被解析的字符串,解析的格式)
			
 
				+使用指定的日期模板获取一个日期格式化器DateTimeFormatter对象
			
 
				+    DateTimeFormatter ofPattern()
			
 
				+    
			
 
				+LocalDateTime增加时间或减少时间的方法：
			
 
				+添加或者减去年     public LocalDateTime plusYears (long years)
			
 
				+添加或者减去月     public LocalDateTime plusMonths(long months)
			
 
				+添加或者减去日     public LocalDateTime plusDays(long days)
			
 
				+添加或者减去时     public LocalDateTime plusHours(long hours)
			
 
				+添加或者减去分     public LocalDateTime plusMinutes(long minutes)
			
 
				+添加或者减去秒     public LocalDateTime plusSeconds(long seconds)
			
 
				+添加或者减去周     public LocalDateTime plusWeeks(long weeks)
			
 
				+
			
 
				+Period-计算时间间隔年月日
			
 
				+计算时间间隔  static Period between(开始时间,结束时间)
			
 
				+获取年数    getYears()
			
 
				+获取月数    getMonths()
			
 
				+获取天数     getDays()
			
 
				+获取间隔这段时间的总月数  toTotalMonths()
			
 
				+
			
 
				+Duration-计算时间间隔时分秒
			
 
				+计算两个"时间"的间隔     public static Duration between(开始时间,结束时间)
			
 
				+获得此时间间隔的秒       public long toSeconds()
			
 
				+获得此时间间隔的毫秒      public int toMillis()
			
 
				+获得此时间间隔的纳秒      public int toNanos()
			
--- a/javaSE/result.txt
+++ b/javaSE/result.txt
@@ -0,0 +1,14 @@
 
				+asd.java：字符数=1776，行数=68
			
 
				+Demo01.java：字符数=883，行数=40
			
 
				+AtomDemo.java：字符数=357，行数=17
			
 
				+MyAtomThread.java：字符数=548，行数=23
			
 
				+AtomDemo.java：字符数=480，行数=22
			
 
				+MyAtomicInteger.java：字符数=1072，行数=39
			
 
				+MyAtomThread.java：字符数=713，行数=29
			
 
				+Main.java：字符数=412，行数=17
			
 
				+Person.java：字符数=2356，行数=103
			
 
				+PersonService.java：字符数=755，行数=31
			
 
				+User.java：字符数=1275，行数=60
			
 
				+UsernameDuplicateException.java：字符数=3391，行数=86
			
 
				+UserService.java：字符数=383，行数=24
			
 
				+UserServiceImpl.java：字符数=1787，行数=70
			
--- a/javaSE/src/J20250714/API文档.txt
+++ b/javaSE/src/J20250714/API文档.txt
@@ -0,0 +1,6 @@
 
				+API(Application Programing Interface) 应用程序编程接口
			
 
				+JDK1.8-API，就是一个API文档就是一个使用说明书
			
 
				+
			
 
				+Java的API
			
 
				+就是Java提供的各种功能的Java类，类的底层被封装起来了。
			
 
				+不用关心是怎么实现的。会用就可以了。
			
--- a/javaSE/src/J20250714/String类常用方法.txt
+++ b/javaSE/src/J20250714/String类常用方法.txt
@@ -0,0 +1,7 @@
 
				+作业1：挨个使用String的以下方法：
			
 
				+String类常用方法，
			
 
				+1、charAt(int index) 返回 char指定索引处的值。
			
 
				+2、toCharArray()  返回一个字符数组
			
 
				+3、subString(int beginIndex, int endIndex)
			
 
				+从beginIndex开始到endIndex结束，返回一个字符串，该字符串是此字符串的子字符串。
			
 
				+4、split(String regex)将这个字符串拆分为指定的字符串。
			
--- a/javaSE/src/J20250714/demo01/Demo03.java
+++ b/javaSE/src/J20250714/demo01/Demo03.java
@@ -0,0 +1,17 @@
 
				+package J20250714.demo01;
			
 
				+
			
 
				+import J20250714.demo02.Demo01;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title Demo03
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class Demo03 {
			
 
				+    public static void main(String[] args) {
			
 
				+        Demo01 demo01=new Demo01();
			
 
				+
			
 
				+    }
			
 
				+}
			
--- a/javaSE/src/J20250714/demo01/Person.java
+++ b/javaSE/src/J20250714/demo01/Person.java
@@ -0,0 +1,55 @@
 
				+package J20250714.demo01;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title Person
			
 
				+ * @description 创建一个Person类
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class Person {
			
 
				+    //属性
			
 
				+    String name;
			
 
				+
			
 
				+    //我们的最终目的是让别人能复制，但是不能随便赋值
			
 
				+    //1、在age前面加private修饰符-->外部不能赋值，内部可以赋值
			
 
				+    //2、实现外部可以赋值
			
 
				+    //3、加以赋值的限制
			
 
				+
			
 
				+    private int age;    //把这个age属性的权限变为私有的，也就是说只有在本类中，才能被使用
			
 
				+    //为年龄赋值的方法
			
 
				+    public void setAge(int age){
			
 
				+        //如果age前面不加this，那么由于就近原则，指向都是局部变量(参数)age
			
 
				+        //加了this.就说明这个age是对象的成员属性age。
			
 
				+        //this的含义就是当前对象。
			
 
				+        //这种方式赋值的好处，就是可以在方法中进行限制，比如加一个if判断
			
 
				+        if(age>0&&age<125){
			
 
				+            this.age=age;
			
 
				+        }else {
			
 
				+            System.out.println("年龄赋值有误");
			
 
				+        }
			
 
				+    }
			
 
				+
			
 
				+    //获取年龄的方法
			
 
				+    public int getAge(){
			
 
				+        return this.age;
			
 
				+    }
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
 
				+    //行为
			
 
				+    public void eat(String sw){
			
 
				+        System.out.println("我今天早上吃"+sw);
			
 
				+    }
			
 
				+    public void sleep(){
			
 
				+        System.out.println("我喜欢睡觉");
			
 
				+    }
			
 
				+    public String work(String nr){
			
 
				+        String s="我今天做"+nr+"工作，收获很多，各种摸鱼";
			
 
				+        return s;
			
 
				+    }
			
 
				+    public String play(){
			
 
				+        return "玩啥都开心";
			
 
				+    }
			
 
				+}
			
--- a/javaSE/src/J20250714/demo01/Phone.java
+++ b/javaSE/src/J20250714/demo01/Phone.java
@@ -0,0 +1,25 @@
 
				+package J20250714.demo01;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title Phone
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class Phone {
			
 
				+    String brand;//品牌
			
 
				+    double price;
			
 
				+    public void call(String name){
			
 
				+        System.out.println("给"+name+"打电话");
			
 
				+    }
			
 
				+    public void sendMessage(){
			
 
				+        System.out.println("发送消息");
			
 
				+    }
			
 
				+    public void method(){
			
 
				+        ///////
			
 
				+        /////
			
 
				+        ////
			
 
				+
			
 
				+    }
			
 
				+}
			
--- a/javaSE/src/J20250714/demo01/TestPerson.java
+++ b/javaSE/src/J20250714/demo01/TestPerson.java
@@ -0,0 +1,19 @@
 
				+package J20250714.demo01;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title TestPerson
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class TestPerson {
			
 
				+    public static void main(String[] args) {
			
 
				+        Person p=new Person();
			
 
				+        p.name="张三";
			
 
				+        //p.age=256;  //赋值是符合Java要求的。但是跟我们的业务是不符的
			
 
				+        p.setAge(56);
			
 
				+        int a=p.getAge();
			
 
				+        System.out.println(a);
			
 
				+    }
			
 
				+}
			
--- a/javaSE/src/J20250714/demo01/TestPhone.java
+++ b/javaSE/src/J20250714/demo01/TestPhone.java
@@ -0,0 +1,23 @@
 
				+package J20250714.demo01;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title TestPhone
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class TestPhone {
			
 
				+    public static void main(String[] args) {
			
 
				+        Phone p=new Phone();
			
 
				+        p.brand="大米";
			
 
				+        p.price=128.6;
			
 
				+
			
 
				+        p.sendMessage();
			
 
				+        p.call("张三");
			
 
				+    }
			
 
				+}
			
 
				+
			
 
				+
			
 
				+
			
 
				+
			
--- a/javaSE/src/J20250714/demo02/Demo01.java
+++ b/javaSE/src/J20250714/demo02/Demo01.java
@@ -0,0 +1,17 @@
 
				+package J20250714.demo02;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title Demo01
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class Demo01 {
			
 
				+    private String name;
			
 
				+    int age;
			
 
				+
			
 
				+    public void setAge(int age){
			
 
				+        this.age=age;
			
 
				+    }
			
 
				+}
			
--- a/javaSE/src/J20250714/demo02/Demo02.java
+++ b/javaSE/src/J20250714/demo02/Demo02.java
@@ -0,0 +1,19 @@
 
				+package J20250714.demo02;
			
 
				+
			
 
				+import J20250714.demo01.Person;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title Demo02
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class Demo02 {
			
 
				+    public static void main(String[] args) {
			
 
				+        Demo01 demo01=new Demo01();
			
 
				+        demo01.age=25;
			
 
				+        Person p=new Person();
			
 
				+
			
 
				+    }
			
 
				+}
			
--- a/javaSE/src/J20250714/demo03/Person.java
+++ b/javaSE/src/J20250714/demo03/Person.java
@@ -0,0 +1,34 @@
 
				+package J20250714.demo03;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title Person
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class Person {
			
 
				+    private String name;
			
 
				+    private int gae;
			
 
				+    //java会默认为所有类的都创建一个构造方法，构造方法的修饰符是根据类的修饰符决定的。
			
 
				+    public Person(){
			
 
				+        System.out.println("我创建了"+this+"对象");
			
 
				+    }
			
 
				+
			
 
				+    public void setName(String name){
			
 
				+        this.name=name;
			
 
				+    }
			
 
				+
			
 
				+    public String getName() {
			
 
				+        return name;
			
 
				+    }
			
 
				+
			
 
				+    public int getGae() {
			
 
				+        return gae;
			
 
				+    }
			
 
				+
			
 
				+    public void setGae(int gae) {
			
 
				+        this.gae = gae;
			
 
				+    }
			
 
				+
			
 
				+}
			
--- a/javaSE/src/J20250714/demo03/Student.java
+++ b/javaSE/src/J20250714/demo03/Student.java
@@ -0,0 +1,51 @@
 
				+package J20250714.demo03;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title Student
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class Student {
			
 
				+
			
 
				+    private String id;
			
 
				+    private String name;
			
 
				+    private int age;
			
 
				+
			
 
				+    //构造方法
			
 
				+    //  创建一个学生对象
			
 
				+    public Student(){   //无参构造方法
			
 
				+        System.out.println("我是一个学生对象");
			
 
				+    }
			
 
				+    //有参构造方法
			
 
				+    public Student(String id,String name,int age){
			
 
				+        this.id=id;
			
 
				+        this.name=name;
			
 
				+        this.age=age;
			
 
				+    }
			
 
				+
			
 
				+    public String getId() {
			
 
				+        return id;
			
 
				+    }
			
 
				+
			
 
				+    public void setId(String id) {
			
 
				+        this.id = id;
			
 
				+    }
			
 
				+
			
 
				+    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;
			
 
				+    }
			
 
				+}
			
--- a/javaSE/src/J20250714/demo03/Teacher.java
+++ b/javaSE/src/J20250714/demo03/Teacher.java
@@ -0,0 +1,52 @@
 
				+package J20250714.demo03;
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * 这个类是教师的类，里面包含了3个成员属性 id、name、age
			
 
				+ *
			
 
				+ * @title Teacher
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class Teacher {
			
 
				+
			
 
				+    private String id;
			
 
				+    private String name;
			
 
				+    private int age;
			
 
				+    //Alt键+insert键
			
 
				+    //鼠标右键点击，展示选项列表，选择generate选项，可以展开生成弹窗
			
 
				+
			
 
				+    public Teacher() {
			
 
				+    }
			
 
				+
			
 
				+    public Teacher(String id, String name, int age) {
			
 
				+        this.id = id;
			
 
				+        this.name = name;
			
 
				+        this.age = age;
			
 
				+    }
			
 
				+
			
 
				+    public String getId() {
			
 
				+        return id;
			
 
				+    }
			
 
				+
			
 
				+    public void setId(String id) {
			
 
				+        this.id = id;
			
 
				+    }
			
 
				+
			
 
				+    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;
			
 
				+    }
			
 
				+}
			
--- a/javaSE/src/J20250714/demo03/TestPerson.java
+++ b/javaSE/src/J20250714/demo03/TestPerson.java
@@ -0,0 +1,25 @@
 
				+package J20250714.demo03;
			
 
				+
			
 
				+
			
 
				+/**
			
 
				+ * @author WanJl
			
 
				+ * @version 1.0
			
 
				+ * @title TestPerson
			
 
				+ * @description
			
 
				+ * @create 2025/7/14
			
 
				+ */
			
 
				+public class TestPerson {
			
 
				+    public static void main(String[] args) {
			
 
				+        //创建Person的对象
			
 
				+        //Java中的引用数据类型变量，默认值都是null空。
			
 
				+        Person p=null;//创建一个Person类型的变量p
			
 
				+        p=new Person(); //为变量p赋值，赋值的是创建的Person对象
			
 
				+        //创建对象其实是调用了Person类的构造方法来实现的。
			
 
				+        System.out.println(p);
			
 
				+        System.out.println(new Person());
			
 
				+        System.out.println(new Person());
			
 
				+        System.out.println(new Person());
			
 
				+        System.out.println(new Person());
			
 
				+    }
			
 
				+
			
 
				+}