<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[FriedReich的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/FriedReich</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; FriedReich]]></copyright><item><title><![CDATA[通识基础22：Java的核心类]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123770584</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123770584</guid><author>FriedReich</author><pubDate>Sun, 27 Mar 2022 11:47:26 +0800</pubDate><description><![CDATA[Java通识基础22：核心类
字符串
public class Main {
    public static void main(String[] args) {
        String a = "Hello";
        String b = "Hello";
        b = b.toLowerCase();//全部字符转化为小写
        System.out.println(b);
        b=b.toUpperCase();
        System.out]]></description><category></category></item><item><title><![CDATA[面向对象通识21（枚举）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123610670</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123610670</guid><author>FriedReich</author><pubDate>Sun, 20 Mar 2022 12:22:37 +0800</pubDate><description><![CDATA[面向对象通识21（枚举）
定义
枚举是实例数量已经固定的类
推论：枚举可以更好地实现单例模式
语法格式
[public] abstract|final enum 枚举名(){
	//要在第一行列出所有的实例——以后就只使用这些实例
	//五大成员
}

public修饰符可以没有，abstract和final修饰符必然存在一个
枚举与普通类的语法区别


枚举默认继承Enum这个类，枚举不能继承其他类


枚举要么是final类，要么是abatract类

如果没有添加抽象方法，那系统默认该类为final类]]></description><category></category></item><item><title><![CDATA[面向对象通识20（函数式接口）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123608980</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123608980</guid><author>FriedReich</author><pubDate>Sun, 20 Mar 2022 10:41:25 +0800</pubDate><description><![CDATA[面向对象通识20（函数式接口）
概述函数式接口
引例：函数式接口：只有一个抽象方法的接口
@FunctionalInterface
//用于修饰函数式接口，作用域之前讲的@Override类似，都是用于报错
//当接口内有两个
public interface Walkable {
    public void move();
    static int sum(int a,int b){
        return a+b;
    }//实例方法1
    default void foo(){
]]></description><category></category></item><item><title><![CDATA[面向对象通识19（内部类）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123604799</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123604799</guid><author>FriedReich</author><pubDate>Sat, 19 Mar 2022 22:43:05 +0800</pubDate><description><![CDATA[面向对象通识19（内部类）
定义在类体中定义的类（包含内部类的类被称为外部类）
基本语法和外部类相同，区别：


可以使用以下三种修饰符


内部类可以用static修饰，表明该内部类为外部类的一个实例


可以用private修饰，表明该内部类只能在外部类中被访问


可以用protected修饰，表名该内部类能在其外部类中被访问，也可以被其子类访问




非静态内部类不能拥有静态成员


内部类可以直接访问外部类的私有成员，但static内部类不能直接访问外部类的非static成员


意义

当某个]]></description><category></category></item><item><title><![CDATA[面向对象通识18（接口）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123596418</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123596418</guid><author>FriedReich</author><pubDate>Sat, 19 Mar 2022 15:52:33 +0800</pubDate><description><![CDATA[面向对象通识18（接口）
语法规则
接口相当于一种彻底抽象的类：
接口体现的是一种规范，要暴露出供用户遵守的规则。
所以，接口都是用public来修饰（通常都不写这个修饰符，它默认存在）
[修饰符] interface 接口名 extands 父接口1, 父接口2....
{
	//成员变量只有常量 并且始终会添加public static final修饰，通常不写
	//抽象方法、类方法、默认方法(默认方法添加方法体)
    //内部类
}

默认方法就是实例方法，与原来的抽象方法的地位完全相同
类是单]]></description><category></category></item><item><title><![CDATA[面向对象通识17（abstract修饰符）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123562358</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123562358</guid><author>FriedReich</author><pubDate>Thu, 17 Mar 2022 22:12:44 +0800</pubDate><description><![CDATA[面向对象通识17（abstract修饰符）
abstract（抽象）
特性
该修饰符只能修饰方法和类
abstract与final是互斥的
原因：

对于类：前者修饰的类必须派生子类，后者修饰的类禁止派生子类
对于方法：前者修饰的方法必须要被重写，后者修饰的方法禁止被重写

抽象类
特征
有得有失——
有得：抽象类可拥有抽象方法（普通类有的，抽象类都有）
有失：抽象类失去了创建对象的功能
抽象类的主要作用——派生子类（子类构造器一定要调用父类构造器一次，因此抽象类必须有构造器）
作用

定义变量
调用类方法]]></description><category></category></item><item><title><![CDATA[面向对象通识16（final变量）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123560871</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123560871</guid><author>FriedReich</author><pubDate>Thu, 17 Mar 2022 21:11:22 +0800</pubDate><description><![CDATA[面向对象通识16（final修饰符）
final可以修饰变量（各种变量）、方法、类
final与abstract是互斥的，无法同时出现。
特性
final修饰类变量

该变量被赋初始值之后，不能被重新赋值。
该变量必须被赋值

final修饰成员变量

对于普通的成员变量，可以不显示指定的初始值，系统会位置分配默认的初始值。

（该初始值分配规则与数组元素的初始值分配规则完全相同）


对于final修饰的成员变量，程序员必须分配指定的初始值


final实例变量，必须显示指定的初始值。只能在以下3个位置]]></description><category></category></item><item><title><![CDATA[面向对象通识15（单例模式）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123538877</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123538877</guid><author>FriedReich</author><pubDate>Wed, 16 Mar 2022 22:50:35 +0800</pubDate><description><![CDATA[面向对象通识15（单例模式）
Java概念——设计模式：对于一批经常出现的涉及场景，前人已经总结了一些较为成功的设计——这就是设计模式。后人学习并模仿，从而提高我们的代码质量。
存在意义
单例模式：在某些场景下，某些类只需要或者只能创建一个实例——


系统的窗口管理器


数据库的引擎访问点


Java程序所在的JRE运行环境
此时需要采用单例模式


创建方法
因为只能有一个实例，所以构造器不能暴露——


隐藏构造器，用户创建不了实例


暴露一个static方法用于创建实例（因为该方法被创建的时候]]></description><category></category></item><item><title><![CDATA[面向对象通识14（static修饰符）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123538855</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123538855</guid><author>FriedReich</author><pubDate>Wed, 16 Mar 2022 22:48:17 +0800</pubDate><description><![CDATA[面向对象通识14（static修饰符）
static并不是字面意义上“静态”的意思，而是类的意思——


有static的成员是类成员


没有static的成员是实例成员
//在C语言中有静态变量这一概念，即将改变量放置于静态存储区
但Java并没有这一概念，static只能修饰成员变量 成员变量、方法、初始化块、内部类

所以，static不能修饰局部变量，局部变量不属于类
static也不能修饰构造器，构造器存在的目的是初始化对象，而对象对标的是实例



static成员——属于类成员——
所有的类]]></description><category></category></item><item><title><![CDATA[面向对象同通识13（_toString和equals）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123468115</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123468115</guid><author>FriedReich</author><pubDate>Sun, 13 Mar 2022 22:36:16 +0800</pubDate><description><![CDATA[面向对象同通识13（_toString和equals）
toString方法
public class Apple {
    private String color;
    private double weight;
    public Apple(){

    }

    public void setColor(String color){
        this.color=color;
    }
    public String getColor(){
        retur]]></description><category></category></item><item><title><![CDATA[面向对象通识12（包装类）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123390377</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123390377</guid><author>FriedReich</author><pubDate>Wed, 09 Mar 2022 23:29:01 +0800</pubDate><description><![CDATA[面向对象通识12（包装类）
Java有8个基本类型：byte\short\int\long\float\double\char\boolean


不能当成对象使用


不能接受null值（只能赋值给引用类型）


为了解决上述问题，Java为这8个基本类型准备了对应的包装类——可以将基本类型包装成对象
byte--Byte
short--Short
int--Integer
long--Long
float--Float
char--Character
boolean--Boolean
规律——完整的名称]]></description><category></category></item><item><title><![CDATA[面向对象基础小回顾]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123342571</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123342571</guid><author>FriedReich</author><pubDate>Mon, 07 Mar 2022 23:21:07 +0800</pubDate><description><![CDATA[面向对象基础小回顾
三种类型（类、接口、枚举）
四个修饰符（private|protected|public|final|static|abstract）
五个成员
定义类的语法
修饰符 class 类名 extands 父类
定义成员变量
修饰符 类型 变量名 [=初始值]
定义方法
修饰符 返回值类型 方法名(形参列表)
{
	语句块
}

定义构造器
修饰符 构造器（类）名(形参列表)
{
	语句块
}

定义初始化块
[static]{
	语句块
}

类的作用

定义变量
创建对象
调用类方法活着]]></description><category></category></item><item><title><![CDATA[面向对象基础11（初始化块）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123287424</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123287424</guid><author>FriedReich</author><pubDate>Fri, 04 Mar 2022 23:30:19 +0800</pubDate><description><![CDATA[面向对象基础11（初始化块）
语法：
[修饰符]{
	各种语句
}

初始化块是没有名字的
修饰符有且只有static

有static修饰的叫类初始化块（静态初始化块）；
没有static修饰的叫做实例初始化块（非静态初始化块）；

类中可有定义变量的语句，但不能有赋值语句；


public class Block{
	int age = 2;
	String name;
	{
		name = "ggttnn"
	}
}



实例初始化块（没有修饰符static）
实例初始化快是一个“假象”——一个]]></description><category></category></item><item><title><![CDATA[面向对象基础10（多态）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123280577</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123280577</guid><author>FriedReich</author><pubDate>Fri, 04 Mar 2022 16:52:26 +0800</pubDate><description><![CDATA[面向对象基础10（多态）
多态的定义
同一个类型的多个实例、在执行同一个方法，呈现出多种行为特征。
变态的定义
同一个类型的实例在执行统一个方法，但是个别对象呈现出变异的行为特征。
态的概念不是状态，而是行为。
多态存在的意义
当Java执行方法时，方法的执行是动态绑定的：
方法总师执行该变量实际所指向对象的方法。
例1：
public class Bird {
    public void fly(){
        System.out.println("Birds Flying");
    }
]]></description><category></category></item><item><title><![CDATA[面向对象基础9（继承与继承语法）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123233529</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123233529</guid><author>FriedReich</author><pubDate>Wed, 02 Mar 2022 16:22:12 +0800</pubDate><description><![CDATA[面向对象基础9（继承）
封装、继承、多态是面向对象的三大特征
继承的理解
苹果（类）继承了水果（类）
老虎（类）继承了动物（类）


Java的继承是类与类之间的关系


是一种由一般到特殊的关系（与现实中的辈分没有关系，所以子类和父类名字并不准确）


——小类（子类）是一种特殊的父类（大类）
子类的实例完全可当做父类的实例来使用
别称
父类（超类、基类、大类）；子类（派生类、小类）
继承的语法
修饰符 class 类名 extends 父类
{代码块}
说明：
Java是单继承的，所以，一个子类只能继承]]></description><category></category></item><item><title><![CDATA[面向对象基础8（构造器与构造器重载）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123167656</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123167656</guid><author>FriedReich</author><pubDate>Sun, 27 Feb 2022 18:01:07 +0800</pubDate><description><![CDATA[面向对象基础8（构造器与构造器重载）

构造器规则：用于初始化对象
必须用关键字new来调用
类必然存在构造器

构造器重载
一个类中可以定义多个构造器，形参列表必然不同
this调用：紧跟括号——this(参数)只能出现在构造器中
​		代表调用同一个类中重载的构造器，只能出现在构造器的第一行
this引用：紧跟一个.——this.name
举例：
public class Constructor {
    private String name;
    private String color;
 ]]></description><category></category></item><item><title><![CDATA[面向对象基础7（包和封装）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123166194</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123166194</guid><author>FriedReich</author><pubDate>Sun, 27 Feb 2022 16:34:47 +0800</pubDate><description><![CDATA[面向对象基础7（包和封装）
面向对象三大特征——封装、集成、多态
封装


隐藏对象的内部实现细节


将一些公共操作的细节暴露
​	如果通过暴露的界面操作对象，该对象的内部状态不会被破坏


简而言之，封装要求合理的隐藏，合理的暴露。
实现方式——访问控制符
private（类访问权限）——该修饰符修饰的成员，只能在该类中被访问
public（公共）——该修饰符修饰的成员可以在任意地方被访问
protected（子类访问权限）——该修饰符修饰的成员，能在该类，该类所在的包以及子类中被访问
默认——（包访问]]></description><category></category></item><item><title><![CDATA[面向对象基础6（变量详解+OOP基础回顾总结）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123158421</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123158421</guid><author>FriedReich</author><pubDate>Sat, 26 Feb 2022 23:39:39 +0800</pubDate><description><![CDATA[面向对象基础6（变量详解+OOP基础回顾总结）
Java变量
成员变量
位置——定义于类中


类变量 有static
类变量属于类而本身，当系统初始化该类的时候就会给类变量分配空间并初始化。
在程序中，类本身只有一个，先有类，再有对象（实例）


实例变量 无static
实例变量属于对象本身，系统每次创建的时候都需要危改对象的实例变量分配空间，并执行初始化
严格来讲，类变量应该由类本身来访问
实例变量应该由对象来访问——永远用类调用类变量、
不要用对象来访问类变量，但是Java还是会将该对象替换为该对象]]></description><category></category></item><item><title><![CDATA[面向对象基础入门5（方法的传参机制）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123143382</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123143382</guid><author>FriedReich</author><pubDate>Fri, 25 Feb 2022 23:54:26 +0800</pubDate><description><![CDATA[面向对象基础入门5（方法的传参机制）
如果定义方法时候声明了形参，调用方法是必须传入对应的参数。
引例：
public class Transfer {
    public static void swap(int a,int b)
    {
        int tmp=a;
        a=b;
        b=tmp;
    }
    public static void main(String[] args) {
        int a=6,b=9;
        Trans]]></description><category></category></item><item><title><![CDATA[面向对象基础4（方法重载）]]></title><link>https://blog.youkuaiyun.com/FriedReich/article/details/123100899</link><guid>https://blog.youkuaiyun.com/FriedReich/article/details/123100899</guid><author>FriedReich</author><pubDate>Wed, 23 Feb 2022 22:24:49 +0800</pubDate><description><![CDATA[面向对象基础4（方法重载）
方法重载：在同一个类中，有多个同名的方法，但这些方法的形参列表是不同的。
——两同一不同（修饰符不同不算重载；返回值类型不同也不算重载）
综上：参数和方法名两个要素才能确定一个方法
举例：
public class Overload {
    public void test()
    {
        System.out.println("无参数的Test方法");
    }
    public void test(int count)
    {
        ]]></description><category></category></item></channel></rss>