<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[weixin_45857066的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/weixin_45857066</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; weixin_45857066]]></copyright><item><title><![CDATA[Java异常2]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113815436</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113815436</guid><author>weixin_45857066</author><pubDate>Mon, 15 Feb 2021 13:23:00 +0800</pubDate><description><![CDATA[Java异常2
自定义异常
使用Java内置的异常类可以描述大部分异常情况，用户自定义异常类只需要继承Exception类即可。

创建自定义异常类
在方法中通过throw关键字抛出异常对象
如果在当前抛出异常的方法中处理异常，可以使用try-catch捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续下一步操作；
在出现异常方法的调用者中捕获并处理异常。

package OOP.exception;
//自定义的异常类
public class MyException]]></description><category></category></item><item><title><![CDATA[Java异常1]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113805134</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113805134</guid><author>weixin_45857066</author><pubDate>Sun, 14 Feb 2021 00:39:00 +0800</pubDate><description><![CDATA[Java异常1
什么是异常
如：写的某个模块，用户输入不符合要求；程序打开某个不存在的文件等。
异常：Exception（分为error与exception，error更严重些）
异常分两类：错误Error与异常Exception，Error无法预见，而Exception可预见
检查性异常、运行时异常（编译时未发现，运行后出现）、错误ERROR（栈溢出等）
Error主要有JVM与UI两类，Exception主要有IO异常与运行异常
如何捕获？为关键
Error类对象由Java虚拟机生成并抛出，大多数错误与]]></description><category></category></item><item><title><![CDATA[Java内部类]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113780884</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113780884</guid><author>weixin_45857066</author><pubDate>Wed, 10 Feb 2021 11:59:44 +0800</pubDate><description><![CDATA[内部类
内部类即在一个类的内部再定义一个类，如在A类中定义一个B类，则B类是A类的内部类。

成员内部类
静态内部类
局部内部类
匿名内部类

package OOP.neibulei;

public class Outer {//最外面的类，即外部类
    private int id;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    class Inner{//内部类
        public v]]></description><category></category></item><item><title><![CDATA[Java接口定义]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113405392</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113405392</guid><author>weixin_45857066</author><pubDate>Fri, 29 Jan 2021 19:57:44 +0800</pubDate><description><![CDATA[Java接口定义与实现
接口不使用class定义
普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，抽象的抽象，专业的约束，约束和实现的分离。公司：面向接口编程。
接口就是规范，定义的是一组规则，体现了现实中的“如果你是xx则必须xx”。
接口的本质是契约，如同法律，制定好后都遵守
OOP的精髓：对对象的抽象，最能体现这一点的即接口
声明类的关键字：class
声明接口的关键字：interface
public interface UserService {//声明一个接口
  ]]></description><category></category></item><item><title><![CDATA[Java抽象类]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113404762</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113404762</guid><author>weixin_45857066</author><pubDate>Fri, 29 Jan 2021 19:16:40 +0800</pubDate><description><![CDATA[Java抽象类
通过abstract修饰的类
抽象类的所有方法，必须由继承它的子类来实现，除非子类也是abstract（则子类的子类来实现）（子承父业，但全是借条，需要子类来还债）
子类只需要实现抽象类的父类的抽象方法即可
public abstract class Action {//抽象类

    //假设方法只是个约束，里面没有内容，最好由别人代替实现（大型框架中写约束）
    //public void doSomething(){ }

    
    public abstract voi]]></description><category></category></item><item><title><![CDATA[Static关键字详解]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113356784</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113356784</guid><author>weixin_45857066</author><pubDate>Thu, 28 Jan 2021 19:39:27 +0800</pubDate><description><![CDATA[Static关键字详解
加在方法上：静态方法
加在属性上：静态属性
静态变量：在静态方法区中
public class Student {
    private static int age;//静态变量
    private double score;//非静态变量
    public static void main(String[] args){
        Student s1 = new Student();
        System.out.println(s1.score);
 ]]></description><category></category></item><item><title><![CDATA[instanceof和类型转换]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113354065</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113354065</guid><author>weixin_45857066</author><pubDate>Thu, 28 Jan 2021 17:52:08 +0800</pubDate><description><![CDATA[instanceof和类型转换
instanceof判断类型
通过instanceof判断对象是什么类型
两类之间存在父子关系则instanceof会ok，否则不行
public class Person {

}

public class Student extends Person{

}

public class Teacher extends Person{

}

import OOP.duotai.Person;
import OOP.duotai.Student;
import OOP.d]]></description><category></category></item><item><title><![CDATA[Java多态]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113268951</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113268951</guid><author>weixin_45857066</author><pubDate>Wed, 27 Jan 2021 20:10:08 +0800</pubDate><description><![CDATA[Java多态
可以实现动态编译，类型实现可扩展性
public class Person {

}

public class Student extends Person{

}

import OOP.duotai.Person;
import OOP.duotai.Student;

public class Application {
    public static void main(String[] args) {
        //一个类new出来的对象的实际类型是确定的
       ]]></description><category></category></item><item><title><![CDATA[Java方法重写]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113188320</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113188320</guid><author>weixin_45857066</author><pubDate>Tue, 26 Jan 2021 19:21:35 +0800</pubDate><description><![CDATA[Java方法重写
IDEA中重写的快捷键：ATL + Insert +Fn，选择Override
重写是属于继承的内容
重写是对方法重写，与属性无关
public class B {
    public static void test(){
        System.out.println("B-test");
    }
}

public class A extends B{		//A继承B
    public static void test(){
        System.out.pr]]></description><category></category></item><item><title><![CDATA[Java super详解]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/113134325</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/113134325</guid><author>weixin_45857066</author><pubDate>Mon, 25 Jan 2021 19:33:14 +0800</pubDate><description><![CDATA[Java继承——super详解
可以与this进行对比
//Person类，父类
public class Person {
    protected String name = "szc";
}


//学生is人，子类，继承父类Person
public class Student extends Person {
    private String name = "Hust";
    public void test(String name){
        System.out.printl]]></description><category></category></item><item><title><![CDATA[Java特性——继承]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/112365134</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/112365134</guid><author>weixin_45857066</author><pubDate>Fri, 08 Jan 2021 15:27:14 +0800</pubDate><description><![CDATA[Java特性——继承
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。即对类进一步抽象。
entends——子类是对父类的拓展
**继承：即扩展，子类为父类的扩展 **
​						父类
​					↓			↓
​				子类1     子类2
​			↓			↓  ↓          ↓
​		对象1   对象2 对象3  对象4
子类：继承父类，即父类的派生类


继承是类与类之间的关系，类与类之间的关系还有：依赖、组合、聚类


继承关系的两个类，一个为子类（派生类），一个为父类（基类]]></description><category></category></item><item><title><![CDATA[Java面向对象特性——封装]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/112222312</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/112222312</guid><author>weixin_45857066</author><pubDate>Tue, 05 Jan 2021 11:48:36 +0800</pubDate><description><![CDATA[Java面向对象特性——封装
即：将程序装到箱子中，仅留有接口供外部使用，内部构造对使用者而言不需要关注
高内聚，低耦合
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：尽量暴露少的方法给外部使用
封装大部分对属性而言，对方法而言较少涉及封装概念
封装的核心：属性的私有，private/public
public class Student {
    private String name;
    private int age;
    private char sex;
}


pub]]></description><category></category></item><item><title><![CDATA[Java小结类与对象]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/112218261</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/112218261</guid><author>weixin_45857066</author><pubDate>Tue, 05 Jan 2021 10:56:01 +0800</pubDate><description><![CDATA[Java小结类与对象
类与对象：
类是一个大的模板，对象是具体的实例
（类中只有属性与方法）
方法：
定义、调用（动态、静态）
对应的引用：
引用类型：8个基本类型
对象是通过引用来操作的：栈—&gt;堆，从栈中指向对象的实际地址（堆中），真实操作的是堆
属性
一般称为字段Field，是一种成员变量
默认初始化：数字为0/0.0，char为u0000，boolean为false，引用类型为null
修饰符：    属性类型  属性名  =  属性值;
属性即其他语言中的变量
对象的创建与使用：

必须使用n]]></description><category></category></item><item><title><![CDATA[Java面向对象3（简要内存分析）]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/112217283</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/112217283</guid><author>weixin_45857066</author><pubDate>Tue, 05 Jan 2021 10:44:51 +0800</pubDate><description><![CDATA[Java面向对象3（简要内存分析）
main()方法在栈中的最下方；即main()方法运行完后基本结束了程序
生成的实例对象在堆中，实例对象作为一个类似指针的引用，实际生成的实例对象内容放在堆空间中，栈中逐行调用语句程序
public class Pet{
    public String name;
    public int age;
    public void shout(){
        System.out.print("叫")
    }
}



public class Appl]]></description><category></category></item><item><title><![CDATA[Java面向对象2（含构造器重要）]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/112215049</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/112215049</guid><author>weixin_45857066</author><pubDate>Tue, 05 Jan 2021 10:18:45 +0800</pubDate><description><![CDATA[Java面向对象2（含构造器重要）
类与对象的关系：
类：描述一类具体的事物应有的特点和行为
对象：是抽象概念的具体实例
类是对象的模板，对象是具体的事物
创建与初始化对象
使用new关键字
不要在每个类中写main方法，一个项目中应只有一个main方法
类中只包含两东西：
属性：变量字段；
方法：即函数。
类需要通过创建具体的对象来实例化
public class Demo2 {
    public static void main(String[] args) {
        Student.sa]]></description><category></category></item><item><title><![CDATA[Java面向对象1]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/111402726</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/111402726</guid><author>weixin_45857066</author><pubDate>Sat, 19 Dec 2020 12:32:49 +0800</pubDate><description><![CDATA[Java面向对象1
OOP——面向对象
面向对象概念
面向过程：由上至下，顺序执行，线性思维，先考虑第一步做什么，第二步做什么…
属性+方法=类
分类思维：物以类聚，同一类别
问题复杂后，如建设楼：总设计师——负责地基的部门、负责钢筋的部分、负责粉刷的部门，每个内部还是面向过程
类似多人协作，整个系统需要多个部分完成（框架），而每个部分都由面向过程具体实现
本质：以类的方式组织代码，以对象的组织（封装）数据
抽象：如学生管理系统，把多个学生的共同点剥离抽取，抽出像的部分，即学号、性别、年龄等特性。
三大特性]]></description><category></category></item><item><title><![CDATA[Java数组]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/111401741</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/111401741</guid><author>weixin_45857066</author><pubDate>Sat, 19 Dec 2020 11:13:29 +0800</pubDate><description><![CDATA[Java数组
数组概述
数组：相同类型数据的有序集合
其中每个数据是一个数组元素，每个数组元素可以通过一个下标来访问，{1，2，3，4，。。。}，{*,&amp;,%,#,…}
数组一旦创建，其长度不可以再改变
数组中的元素可以为任何数据类型，包括基本类型和引用类型
数组变量属于引用类型，数组也可以看成是对象，数组中每个元素相当于该对象的成员变量
数组本身就是对象，Java中对象是在堆中的。
数组也可以看成是对象（也是通过new创建的），数组中每个元素相当于该对象的成员变量：用length或.xxx可以取出]]></description><category></category></item><item><title><![CDATA[Java冒泡排序]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/111356832</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/111356832</guid><author>weixin_45857066</author><pubDate>Fri, 18 Dec 2020 12:03:09 +0800</pubDate><description><![CDATA[Java冒泡排序
冒泡：比较每两个之间的大小，每次排出一个最小/大的数
两层循环，外层为冒泡轮数，内层是依次比较
时间复杂度：O(n^2)
1.比较数组中，两个相邻的元素，如果第一个比第二个数大，则交换其位置
2.每一次比较，都会产生一个最大或者最小的数
3.下一轮可以少一次排序
4.依次循环直到结束
外层循环：判断走多少次（i = length-1）
内层循环：比较两个数大小（j = length-1-i）
package Array;

import java.util.Arrays;

public ]]></description><category></category></item><item><title><![CDATA[Java计算器]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/111311664</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/111311664</guid><author>weixin_45857066</author><pubDate>Thu, 17 Dec 2020 11:23:41 +0800</pubDate><description><![CDATA[Java计算器
package Homework;

import java.util.Scanner;

public class Calculator {
    static char x;
    static double i,j;
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数字：")]]></description><category></category></item><item><title><![CDATA[Java递归]]></title><link>https://blog.youkuaiyun.com/weixin_45857066/article/details/111310724</link><guid>https://blog.youkuaiyun.com/weixin_45857066/article/details/111310724</guid><author>weixin_45857066</author><pubDate>Thu, 17 Dec 2020 10:53:29 +0800</pubDate><description><![CDATA[Java递归
A方法调用A方法，自己调用自己
递归头
递归体
一定要有边界条件：有递归出口，避免内存溢出；
递归深度越大，越占用内存。
基数较大后，尽量避免递归。
递归思想：大问题逐步拆解为一步步的小问题。
package Method;

import java.util.Scanner;

public class Demo6 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(Syst]]></description><category></category></item></channel></rss>