<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[fbl_csdn的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/fbl_csdn</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; fbl_csdn]]></copyright><item><title><![CDATA[[javase学习笔记]-9.3 子父类中成员变量特征体现]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50509110</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50509110</guid><author>fbl_csdn</author><pubDate>Wed, 13 Jan 2016 10:52:52 +0800</pubDate><description><![CDATA[这一节我们来说一说继承中子父类中的成员变量有什么特征。
我们先看从一个例子说起：

class Father//父类
{
	int age1 = 48;
}
class Son extends Father//子类
{
	int age2 = 22;
	public void printInfo()
	{
		System.out.println("父亲的年龄："+age1+"\n儿子的年龄]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-9.2 单继承与多重继承]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50503160</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50503160</guid><author>fbl_csdn</author><pubDate>Tue, 12 Jan 2016 12:03:35 +0800</pubDate><description><![CDATA[这一节我们来看java中的单继承和多重继承。
在java语言中，支持的是单继承，不直接支持多继承，但是对C++中的多继承进行了改良。


那么什么是单继承和多继承呢？
单继承：一个子类只能有一个直接父类。
多继承：一个子类可以有多个直接父类。这个在java中是不允许的。


为什么不允许呢？我们看一个例子：

class A
{
	void method()
	{
		Sys]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-9.1 继承]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50497303</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50497303</guid><author>fbl_csdn</author><pubDate>Mon, 11 Jan 2016 15:26:04 +0800</pubDate><description><![CDATA[这一节我们学习面向对象的第二个特征——继承。


那么什么是继承呢？继承有作用是什么？
我们先通过一个例子来说明：

class Student//学生类
{
	String name;//姓名
	int age;//年龄
	void printInfo()//打印信息
	{
		System.out.println("姓名："+name+"\t年龄："+age);
	}
	void ]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-8.8 构造代码块]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50473789</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50473789</guid><author>fbl_csdn</author><pubDate>Thu, 07 Jan 2016 08:57:58 +0800</pubDate><description><![CDATA[这一节我们再看一个特殊的代码块，那就是构造代码块。


这里我们简单的通过例子来说明一下：

class Person
{
	private String name;
	{
		System.out.println("Person类的第一个代码块被执行");
	}

	Person()
	{
		System.out.println("无参数构造函数被执行");
		this.name]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-8.7 静态代码块]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50470108</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50470108</guid><author>fbl_csdn</author><pubDate>Wed, 06 Jan 2016 16:42:32 +0800</pubDate><description><![CDATA[这一节我们看一个比较特殊的概念，那就是静态代码块。


前面我们也提到过代码块，就是一段独立的代码空间，那么什么是静态代码块呢？说白了，就是用static关键字修饰的代码块。
我们来看一个例子：

class StaticBlock
{
	static
	{
		System.out.println("静态代码块被执行");
	}
	void myPrint()
	{
		System]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-8.6 静态的内存加载]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50466541</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50466541</guid><author>fbl_csdn</author><pubDate>Wed, 06 Jan 2016 08:40:12 +0800</pubDate><description><![CDATA[之前几节我们一直在说static关键字所修饰的静态，那么在程序运行时，内存中static是如何体现的呢？这一节我们就来看一看。


我们还是先看一个例子，希望我们通过对这个例子的分析让我们初学者们对static所修饰的静态在内存中的具体体现有一个深刻的理解。

class Person
{
	String name;//姓名，这是一个成员变量
	int age;
	static Stri]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-8.5 static关键字的使用场景]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50461289</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50461289</guid><author>fbl_csdn</author><pubDate>Tue, 05 Jan 2016 11:27:24 +0800</pubDate><description><![CDATA[这一节我们来看一下在我们开发的过程中，在什么时候我们要用到static关键字进行静态修饰。


我们这里所说的静态，无非就是两种，一种是静态变量，一种是静态函数，我们分这两种情况进行说明static关键字的使用场合。


一、静态变量
我们在7.8节中对static关键字特点和7.9节中成员变量与静态变量区别进行学习的时候就已经很明确的指出了静态变量是共享数据，而对象中封装的特有数据]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-8.4 main函数的解析与细节]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50439366</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50439366</guid><author>fbl_csdn</author><pubDate>Thu, 31 Dec 2015 08:11:46 +0800</pubDate><description><![CDATA[上一节我们说了静态使用细节时提到了main函数是静态的,其实,对于我们初学者,真是对main函数是什么样认识还很模糊,那么这一节我们就解析一下main函数.


main函数的固定格式:public static void main(String[] args)

java语言中主函数有两个特殊之处:
1.格式是固定的.
2.被jvm所识别和调用.


那么它们第一个单词都有什]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-8.3 static关键字使用的注意细节]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50432177</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50432177</guid><author>fbl_csdn</author><pubDate>Wed, 30 Dec 2015 08:26:48 +0800</pubDate><description><![CDATA[这一节我们看静态在使用过程中应注意的几个细节。


上一节我们在学习成员变量与静态变量的区别时，对于两种变量的调用方式不同时出现了“无法从静态上下文中访问非静态变量”的错误，这个问题我们在以后会经常遇到。那么这是什么问题呢？我们从例子说起，我们把上一节中的Person类中方法printInfo进行静态修饰：

class Person
{
	String name;//姓名，这是一个成员]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-8.2 成员变量与静态变量的区别]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50423729</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50423729</guid><author>fbl_csdn</author><pubDate>Tue, 29 Dec 2015 08:52:57 +0800</pubDate><description><![CDATA[这一节我们看一看成员变量与静态变量的区别所在。


什么是静态变量呢？我们上节用static关键字时就提到了静态变量。也就是说用static关键字修饰的变量就是静态变量。
我们在6.4节学习了成员变量与局部变量的区别，这一节我们重点看看成员变量与静态变量之间的区别。
我们看代码：

class Person
{
	String name;//姓名，这是一个成员变量
	static S]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-8.1 static关键字之特点]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50419656</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50419656</guid><author>fbl_csdn</author><pubDate>Mon, 28 Dec 2015 16:07:34 +0800</pubDate><description><![CDATA[这一节我们来学习java语言中一个新的关键字就是static关键字。


当然对于每一个关键字，我们都要明确的是它有什么作用，怎么用。我们先来看一个例子：

class Person
{
	String name;//姓名
	String country = "中国";//国籍

	public void printInfo()
	{
		System.out.println(name+]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-7.7 this关键字的细节与应用]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50411331</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50411331</guid><author>fbl_csdn</author><pubDate>Sun, 27 Dec 2015 09:04:57 +0800</pubDate><description><![CDATA[这一节我们接着上一节来继续学习this关键字.
我们之前在7.5节中的构造函数应注意的细节中提到过一个细节就是构造函数可以调用一般函数,但一般函数不能直接调用构造函数.但是我们没有深究构造函数能不能调用构造函数,那么现在我们就来看一看这个问题.
那么构造函数与构造函数之间是怎么访问呢?
为了掌握这个问题,我们必须要明确一个概念,那就是在一个类中的成员如果要被执行,就必须由对象调用.而每个对象]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-7.6 this关键字的原理]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50407571</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50407571</guid><author>fbl_csdn</author><pubDate>Sat, 26 Dec 2015 10:10:11 +0800</pubDate><description><![CDATA[这一节我们来讲一个关键字，就是this关键字。
我们还是通过例子来看吧：
class Person
{
	private String name;
	private int age;

	Person(String n,int a)
	{
		name = n;
		age = a;
	}

	public void speak()
	{
		System.out.println(name+"]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-7.5 构造函数需要注意的几个细节]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50401174</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50401174</guid><author>fbl_csdn</author><pubDate>Fri, 25 Dec 2015 09:38:46 +0800</pubDate><description><![CDATA[这一节我们简单的说几个在使用构造函数时需要注意的细节。




通过我们前几节的学习，我们对构造函数有了一个比较清楚的认识，当我们在创建对象时，我们会调用构造函数。那么我们在定义和调用构造函数时，需要注意哪些细节呢？




第一个需要注意的细节：构造函数与set方法

看两个函数代码：





[java] view
 plaincopy]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-7.4 构造函数的内存加载]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50394569</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50394569</guid><author>fbl_csdn</author><pubDate>Thu, 24 Dec 2015 15:07:51 +0800</pubDate><description><![CDATA[这一节我们来说说构造函数在内存中是如何被加载的。


我们之前说过，构造函数只有创建对象时才会被调用并且只调用一次。那么在创建对象的过程中内存中的变化是什么样的呢？
我们接着上一节的Person类，我们分析
class Person
{
	private String name;
	private int age;

	Person()//构造函数，分别为成员变量name和age赋固定的]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-7.3 构造函数的重载]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50385571</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50385571</guid><author>fbl_csdn</author><pubDate>Wed, 23 Dec 2015 11:16:55 +0800</pubDate><description><![CDATA[这一节我们来学习一下构造函数的重载。
说到重载，我们在函数那一章已经学习过了，为了更好的理解构造函数的重载，我们先要弄明白一个问题：
那就是什么时候定义构造函数呢？
在描述事物时，该事物已存在就具备一些内容，这些内容都定义在构造函数中。
我们来看例子：

class Person
{
	private String name;
	private int age;

	Person()
]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-7.2 构造函数与一般函数的区别]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50384156</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50384156</guid><author>fbl_csdn</author><pubDate>Wed, 23 Dec 2015 07:05:20 +0800</pubDate><description><![CDATA[这一节我们简单学习一下构造函数与一般函数之间的区别所在。
那么它们有什么区别呢，结合上一节，我们可以总结出以下两点区别：
第一个区别：
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。
一般函数：对象创建后，需要函数功能时，才调用函数。
这也就是说创建对象时，构造函数一定被调用，而一般函数不一定被调用。
第二个区别：
构造函数：对象创建时，会调用且只调用一次。
]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-7.1 构造函数概述与默认构造函数]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50378945</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50378945</guid><author>fbl_csdn</author><pubDate>Tue, 22 Dec 2015 11:52:11 +0800</pubDate><description><![CDATA[这一节我们来学习一个特殊的函数，那就是构造函数。
那么什么是构造函数呢？
既然是函数，那它应该是被定义在类中，同时有函数名，要明确函数返回的结果和参数类型。


我们这里先看一下构造函数的特点：
1.函数名与类名相同；
2.不用定义返回值类型
3.没有具体的返回值。
从这些特点来说，这确实是一个很特殊的函数哦。
我们来看一个定义构造函数的例子：

class Person
]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-6.7 封装]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50366432</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50366432</guid><author>fbl_csdn</author><pubDate>Sun, 20 Dec 2015 23:10:17 +0800</pubDate><description><![CDATA[这一节我们学习面向对象中的第一个特性,封装(encapsulation)


封装:是指隐藏对象的发生和实现细节,仅对外提供公共访问方式.
那么什么是隐藏对象的实现细节?我们来举例学习.
比如我们来定义一个人的类,简单点说,人的属性有年龄,行为有说话.
我们看下面的代码:
class Person//定义一个人的类
{
	int age;
	void speak()
	{
		Sys]]></description><category></category></item><item><title><![CDATA[[javase学习笔记]-6.6 基本数据类型参数与引用数据类型参数的传递过程]]></title><link>https://blog.youkuaiyun.com/fbl_csdn/article/details/50363331</link><guid>https://blog.youkuaiyun.com/fbl_csdn/article/details/50363331</guid><author>fbl_csdn</author><pubDate>Sun, 20 Dec 2015 10:35:01 +0800</pubDate><description><![CDATA[这一节基本数据类型参数和引用数据类型参数的传递过程。


数据类型参数和引用参数我们在前面章节中都已涉及到了，那么我们来看看下面的两段代码：
//基本数据类型参数传递
class Demo
{
	public static void main(String[] args) 
	{
		int x = 3;
		change(x);//调用方法
		System.out.println("x]]></description><category></category></item></channel></rss>