<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[fight_onlyfor_you的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/fight_onlyfor_you</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; fight_onlyfor_you]]></copyright><item><title><![CDATA[Java day6]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85815932</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85815932</guid><author>fight_onlyfor_you</author><pubDate>Sat, 05 Jan 2019 01:52:33 +0800</pubDate><description><![CDATA[
//在后面的你会发现，安卓代码中大量使用内部类，什么叫做内部类呢，我们在一个类的里面重新定义一个新类，这个新类就叫做内部类。

//这个Outer就是个外部类。
class Outer{
    //这个Inner就是内部类。我们为什么要使用内部类，他有一个唯一的好处，可以访问外部内的私有属性
    
    //比如说我们在外部类里面定义一个私有属性
    private int a=10...]]></description><category></category></item><item><title><![CDATA[Java day5]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85815322</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85815322</guid><author>fight_onlyfor_you</author><pubDate>Sat, 05 Jan 2019 01:47:50 +0800</pubDate><description><![CDATA[
//包和权限：
//  以前我们编译java程序的时候用的命令类似于 javac A.java 将在当前目录下
//              生成A.class 
//  那我能不能把class文件放到其他目录下呢。是可以的，这就需要引入包的概念
//  包实际上就是文件夹。包实际上就是个文件夹，你可以在JAVA程序的源代码里面
//  用package指定一个文件夹的目录。当你编译这个程序的...]]></description><category></category></item><item><title><![CDATA[java day4]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85814714</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85814714</guid><author>fight_onlyfor_you</author><pubDate>Sat, 05 Jan 2019 01:32:52 +0800</pubDate><description><![CDATA[


public class Abnormal
{

    //学习JAVA的异常，我们只要记住这几点就可以了
    //分为必须处理的异常和可以不处理的异常
    //对于必须处理的异常，你怎么处理呢
    //可以自己处理，或者让别人处理
    //如果是自己处理，就用
    //try...catch...finally处理
    //让别人处理就是通过throw扔给别人就行...]]></description><category></category></item><item><title><![CDATA[Java day3]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85813733</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85813733</guid><author>fight_onlyfor_you</author><pubDate>Sat, 05 Jan 2019 01:09:35 +0800</pubDate><description><![CDATA[
class Person
{

    private int age;
    public Person()
    {}
    public Person(int age)
    {
        this.age=age;
    }
    public void SetAge(int age)
    {
        this.age=age;
    }

    pub...]]></description><category></category></item><item><title><![CDATA[Java day2]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85649750</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85649750</guid><author>fight_onlyfor_you</author><pubDate>Wed, 02 Jan 2019 23:43:45 +0800</pubDate><description><![CDATA[
public class Function
{
    //在JAVA语言里面函数叫做方法
    //格式
    //  public static 返回值类型 方法名称(类型 参数1，类型 参数2,...)
    //  {
    //      程序语句
    //      [return 表达式];
    //  }
    //
    //这里和C++一样存在重载。
  ...]]></description><category></category></item><item><title><![CDATA[Java day1]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85646713</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/85646713</guid><author>fight_onlyfor_you</author><pubDate>Wed, 02 Jan 2019 22:50:59 +0800</pubDate><description><![CDATA[
//这里最好大写，因为在JAVA的编程规范里面，类的名字首字母要大写，而文件的名字要跟类名保持一致                                                        
//这里是不符合规定的，这里正确的应该是 文件名为Hello.java  类名应该叫public class Hello
//下面是第一个java应用程序
/*
    public c...]]></description><category></category></item><item><title><![CDATA[C++抛出异常]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80490757</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80490757</guid><author>fight_onlyfor_you</author><pubDate>Tue, 29 May 2018 01:51:34 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
#include&amp;lt;cmath&amp;gt;
using namespace std;
#if 0
//C语言中错误的处理，通常是采用返回值的方式或是置位全局变量的方式。这就存在两个问题。如果返回值正是我们需要的数据，且返回数据同出错数据容错差不多。全局变量，在多线程中易发生竞争。而且，当错误发生的时候，上级函数要出错处理，层层上报，造成过多的出错处...]]></description><category></category></item><item><title><![CDATA[C++输入输出流]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80317382</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80317382</guid><author>fight_onlyfor_you</author><pubDate>Tue, 15 May 2018 01:08:41 +0800</pubDate><description><![CDATA[cin和cout充当了scanf和printf的功能，但是他们不是函数，而是类对象，那么我们有必要了解一下，他们是哪些类的对象。关于输入输出流有下图这么一个整套的东西，这整套东西很复杂，我们一般来说不去研究，但是呢，我们可以从继承关系看出它属于哪个流类的对象，首先有一个叫ios_base,ios继承ios_base,这个箭头画的不对，真正的继承体系中，箭头应该指向父类。ios又派生了istream...]]></description><category></category></item><item><title><![CDATA[C++之verctor]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80296505</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80296505</guid><author>fight_onlyfor_you</author><pubDate>Sun, 13 May 2018 02:57:53 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
#include&amp;lt;vector&amp;gt;
using namespace std;

int main()
{
    //这里相比较前面的，vector其实是个类模板，然后你vector&amp;lt;int&amp;gt;就是个模板类。
    //vi就是个类对象，然后这个10就是个参数。它里面有两个很重要的东西，输出这个东西。
    //这个size...]]></description><category></category></item><item><title><![CDATA[C++之模板]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80296471</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80296471</guid><author>fight_onlyfor_you</author><pubDate>Sun, 13 May 2018 02:07:33 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
using namespace std;
/*
 * 模板:Templates
 * 泛型(Generic Programming)即是指具有在多种数据类型上皆可操作的含意。泛型编程的代表作品STL是一种高效、泛型、可交互操作的软件组件
 * 泛型编程最初诞生于C++中，目的是为了实现C++的STL(标准模板库)。其语言支持机制就是模板(Templ...]]></description><category></category></item><item><title><![CDATA[C++day26之rtti]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80209130</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/80209130</guid><author>fight_onlyfor_you</author><pubDate>Mon, 07 May 2018 23:47:06 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
#include&amp;lt;typeinfo&amp;gt;
using namespace std;

typedef void (*PF)(int);
/*
 *RTTI:run time type identification
 typeid,dynamic_cast运行时类型信息，在运行时需要检查类型信息的，那就是多态。所以说这两个东西只有用于多态才有...]]></description><category></category></item><item><title><![CDATA[C++学习之25]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79860329</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79860329</guid><author>fight_onlyfor_you</author><pubDate>Mon, 09 Apr 2018 01:15:44 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
using namespace std;
#if 0
C++有一种设计原则叫做依赖导致，也是基于多态的。
定义：高层模块不应该依赖低层模块，二者都应该依赖其抽象;抽象不应该依赖细节;
细节应该依赖抽象。

#endif
//这个I是interface的意思。
class IReader
{
public:
    virtual string ge...]]></description><category></category></item><item><title><![CDATA[C++学习Day24z之多态]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79838576</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79838576</guid><author>fight_onlyfor_you</author><pubDate>Sat, 07 Apr 2018 03:35:06 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
using namespace std;
/*C++中所谓的多态(polymorphism)是指，由继承而产生的相关的不同的类，其对象对同一消息会作出不同的相应
 * 多态性是面向对象程序设计的一个重要特性，能增加程序的灵活性，可以减轻系统升级，维护调试的工作量和复杂度。*/

/*多态实现的前提是赋值兼容。
 * 赋值兼容规则是指在需要基类对象的...]]></description><category></category></item><item><title><![CDATA[C++学习day23之多继承]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79751486</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79751486</guid><author>fight_onlyfor_you</author><pubDate>Fri, 30 Mar 2018 01:25:27 +0800</pubDate><description><![CDATA[从继承的类别上分，继承可以分成多继承和单继承，前面讲的都是单继承。这里其实很容易划分，单继承就是一个父类，多继承就是多个父类。在生活当中有什么意思呢，生活当中，鱼与熊掌不可兼得。但是到了计算机就可以实现，生成一种新的对象，叫做熊掌鱼，多继承自鱼和熊掌即可。再拿我们的沙发床来说，即可以当沙发又可以当床。#include&amp;lt;iostream&amp;gt;
using namespace std;

cl...]]></description><category></category></item><item><title><![CDATA[C++学习day22之继承与派生]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79721476</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79721476</guid><author>fight_onlyfor_you</author><pubDate>Wed, 28 Mar 2018 01:16:33 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;

using namespace std;

/*
 *类内部的private protected public 影响的访问权限
 *继承中的private protected public 影响的是父类中的成员在子类中的访问权限的 问题  这个访问权限包括两部分。1.在子类中 2.在子类对象中。
 *99%情况下只是用public继承方式。
 *...]]></description><category></category></item><item><title><![CDATA[派生类的友员函数]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79684909</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79684909</guid><author>fight_onlyfor_you</author><pubDate>Sun, 25 Mar 2018 11:29:04 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
using namespace std;
class Student
{
public:
    Student()
        :a(50),b(60)
    {
    
    }
    friend ostream &amp;amp;operator&amp;lt;&amp;lt;(ostream &amp;amp;out,Student &amp;amp;stu);
p...]]></description><category></category></item><item><title><![CDATA[C++学习day21之继承与派生2]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79418905</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79418905</guid><author>fight_onlyfor_you</author><pubDate>Fri, 02 Mar 2018 01:36:17 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
using namespace std;
/*
 *这里会输出Father和Son,
 *跟我们前面讲的不一样啊。
 *这里的父类构造器调用了。
 */ 
#if 0
class Father
{
public:
    Father()
    {
        cout&amp;lt;&amp;lt;&quot;Father&quot;&amp;lt;&amp;lt;endl;       
...]]></description><category></category></item><item><title><![CDATA[C++学习day20之继承与派生1]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79418629</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79418629</guid><author>fight_onlyfor_you</author><pubDate>Thu, 01 Mar 2018 23:42:26 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
using namespace std;
/*
 *
 *Inherit(继承)&amp;amp;&amp;amp;Derive(派生)这个单词看起来是两个不同的单词
 *但是表达的是一个意思  儿子继承父亲，父亲派生儿子
 *这两个从不同的角度去说明父子关系，只是角度不一样
 *那么继承和派生到底解决了什么问题呢，解决了C++中可重用性
 *
 */

/*
 ...]]></description><category></category></item><item><title><![CDATA[C++之伪函数]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79372817</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79372817</guid><author>fight_onlyfor_you</author><pubDate>Mon, 26 Feb 2018 00:56:37 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
#include&amp;lt;vector&amp;gt;
#include&amp;lt;algorithm&amp;gt;
using namespace std;
/*
 *函数操作符()-----仿函数
 *把类对象像函数名一样使用
 *伪函数，就是使用一个类的使用看上去像一个函数，其实现就是类中实现一个
 *operator()，这个类就有了类似函数的行为，就是一个伪...]]></description><category></category></item><item><title><![CDATA[C++学习day18之 指向类成员的指针]]></title><link>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79372807</link><guid>https://blog.youkuaiyun.com/fight_onlyfor_you/article/details/79372807</guid><author>fight_onlyfor_you</author><pubDate>Mon, 26 Feb 2018 00:51:54 +0800</pubDate><description><![CDATA[#include&amp;lt;iostream&amp;gt;
using namespace std;

//指向类成员的指针
//类成员就包含两类，一类是数据成员，一类是函数成员。
//一定要看好，这里是类数据成员，不是对象数据成员
//指向类数据成员的指针
//定义&amp;lt;数据类型&amp;gt;&amp;lt;类名&amp;gt;::*&amp;lt;指针名&amp;gt;
//赋值&amp;amp;初始化
//&amp;lt;数据类型&amp;gt;&amp;lt;类名&amp;...]]></description><category></category></item></channel></rss>