代码拉取完成，页面将自动刷新
同步操作将从 ShuoWang/Blog_Django 强制同步，此操作会覆盖自 Fork 仓库以来所做的任何修改，且无法恢复！！！
确定后同步将在后台操作，完成时将刷新页面，请耐心等待。
/*
SQLyog Ultimate v12.4.1 (64 bit)
MySQL - 5.7.22-log : Database - py_blog
*********************************************************************
*/
/*!40101 SET NAMES utf8 */;
/*!40101 SET SQL_MODE=''*/;
/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`py_blog` /*!40100 DEFAULT CHARACTER SET utf8 */;
USE `py_blog`;
/*Table structure for table `auth_group` */
DROP TABLE IF EXISTS `auth_group`;
CREATE TABLE `auth_group` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(150) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `name` (`name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `auth_group` */
/*Table structure for table `auth_group_permissions` */
DROP TABLE IF EXISTS `auth_group_permissions`;
CREATE TABLE `auth_group_permissions` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`group_id` int(11) NOT NULL,
`permission_id` int(11) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `auth_group_permissions_group_id_permission_id_0cd325b0_uniq` (`group_id`,`permission_id`),
KEY `auth_group_permissio_permission_id_84c5c92e_fk_auth_perm` (`permission_id`),
CONSTRAINT `auth_group_permissio_permission_id_84c5c92e_fk_auth_perm` FOREIGN KEY (`permission_id`) REFERENCES `auth_permission` (`id`),
CONSTRAINT `auth_group_permissions_group_id_b120cbf9_fk_auth_group_id` FOREIGN KEY (`group_id`) REFERENCES `auth_group` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `auth_group_permissions` */
/*Table structure for table `auth_permission` */
DROP TABLE IF EXISTS `auth_permission`;
CREATE TABLE `auth_permission` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) NOT NULL,
`content_type_id` int(11) NOT NULL,
`codename` varchar(100) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `auth_permission_content_type_id_codename_01ab375a_uniq` (`content_type_id`,`codename`),
CONSTRAINT `auth_permission_content_type_id_2f476e4b_fk_django_co` FOREIGN KEY (`content_type_id`) REFERENCES `django_content_type` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=37 DEFAULT CHARSET=utf8;
/*Data for the table `auth_permission` */
insert into `auth_permission`(`id`,`name`,`content_type_id`,`codename`) values
(1,'Can add log entry',1,'add_logentry'),
(2,'Can change log entry',1,'change_logentry'),
(3,'Can delete log entry',1,'delete_logentry'),
(4,'Can view log entry',1,'view_logentry'),
(5,'Can add permission',2,'add_permission'),
(6,'Can change permission',2,'change_permission'),
(7,'Can delete permission',2,'delete_permission'),
(8,'Can view permission',2,'view_permission'),
(9,'Can add group',3,'add_group'),
(10,'Can change group',3,'change_group'),
(11,'Can delete group',3,'delete_group'),
(12,'Can view group',3,'view_group'),
(13,'Can add content type',4,'add_contenttype'),
(14,'Can change content type',4,'change_contenttype'),
(15,'Can delete content type',4,'delete_contenttype'),
(16,'Can view content type',4,'view_contenttype'),
(17,'Can add session',5,'add_session'),
(18,'Can change session',5,'change_session'),
(19,'Can delete session',5,'delete_session'),
(20,'Can view session',5,'view_session'),
(21,'Can add 用户管理',6,'add_user'),
(22,'Can change 用户管理',6,'change_user'),
(23,'Can delete 用户管理',6,'delete_user'),
(24,'Can view 用户管理',6,'view_user'),
(25,'Can add 类别管理',7,'add_articlecategory'),
(26,'Can change 类别管理',7,'change_articlecategory'),
(27,'Can delete 类别管理',7,'delete_articlecategory'),
(28,'Can view 类别管理',7,'view_articlecategory'),
(29,'Can add 文章管理',8,'add_article'),
(30,'Can change 文章管理',8,'change_article'),
(31,'Can delete 文章管理',8,'delete_article'),
(32,'Can view 文章管理',8,'view_article'),
(33,'Can add 评论管理',9,'add_comment'),
(34,'Can change 评论管理',9,'change_comment'),
(35,'Can delete 评论管理',9,'delete_comment'),
(36,'Can view 评论管理',9,'view_comment');
/*Table structure for table `django_admin_log` */
DROP TABLE IF EXISTS `django_admin_log`;
CREATE TABLE `django_admin_log` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`action_time` datetime(6) NOT NULL,
`object_id` longtext,
`object_repr` varchar(200) NOT NULL,
`action_flag` smallint(5) unsigned NOT NULL,
`change_message` longtext NOT NULL,
`content_type_id` int(11) DEFAULT NULL,
`user_id` int(11) NOT NULL,
PRIMARY KEY (`id`),
KEY `django_admin_log_content_type_id_c4bce8eb_fk_django_co` (`content_type_id`),
KEY `django_admin_log_user_id_c564eba6_fk_tb_users_id` (`user_id`),
CONSTRAINT `django_admin_log_content_type_id_c4bce8eb_fk_django_co` FOREIGN KEY (`content_type_id`) REFERENCES `django_content_type` (`id`),
CONSTRAINT `django_admin_log_user_id_c564eba6_fk_tb_users_id` FOREIGN KEY (`user_id`) REFERENCES `tb_users` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
/*Data for the table `django_admin_log` */
insert into `django_admin_log`(`id`,`action_time`,`object_id`,`object_repr`,`action_flag`,`change_message`,`content_type_id`,`user_id`) values
(1,'2020-06-13 00:31:48.320322','1','Java',1,'[{\"added\": {}}]',7,5),
(2,'2020-06-13 00:31:53.100535','2','Python',1,'[{\"added\": {}}]',7,5),
(3,'2020-06-13 00:32:05.143287','3','JavaScript',1,'[{\"added\": {}}]',7,5),
(4,'2020-06-13 00:32:11.053175','4','MySQL',1,'[{\"added\": {}}]',7,5),
(5,'2020-06-13 00:32:17.094688','5','计算机网络',1,'[{\"added\": {}}]',7,5),
(6,'2020-06-13 00:32:21.625519','6','PHP',1,'[{\"added\": {}}]',7,5);
/*Table structure for table `django_content_type` */
DROP TABLE IF EXISTS `django_content_type`;
CREATE TABLE `django_content_type` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`app_label` varchar(100) NOT NULL,
`model` varchar(100) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `django_content_type_app_label_model_76bd3d3b_uniq` (`app_label`,`model`)
) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8;
/*Data for the table `django_content_type` */
insert into `django_content_type`(`id`,`app_label`,`model`) values
(1,'admin','logentry'),
(3,'auth','group'),
(2,'auth','permission'),
(4,'contenttypes','contenttype'),
(8,'home','article'),
(7,'home','articlecategory'),
(9,'home','comment'),
(5,'sessions','session'),
(6,'users','user');
/*Table structure for table `django_migrations` */
DROP TABLE IF EXISTS `django_migrations`;
CREATE TABLE `django_migrations` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`app` varchar(255) NOT NULL,
`name` varchar(255) NOT NULL,
`applied` datetime(6) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=22 DEFAULT CHARSET=utf8;
/*Data for the table `django_migrations` */
insert into `django_migrations`(`id`,`app`,`name`,`applied`) values
(1,'contenttypes','0001_initial','2020-06-12 01:53:42.788306'),
(2,'contenttypes','0002_remove_content_type_name','2020-06-12 01:53:42.961875'),
(3,'auth','0001_initial','2020-06-12 01:53:43.083518'),
(4,'auth','0002_alter_permission_name_max_length','2020-06-12 01:53:43.473474'),
(5,'auth','0003_alter_user_email_max_length','2020-06-12 01:53:43.482449'),
(6,'auth','0004_alter_user_username_opts','2020-06-12 01:53:43.490428'),
(7,'auth','0005_alter_user_last_login_null','2020-06-12 01:53:43.498406'),
(8,'auth','0006_require_contenttypes_0002','2020-06-12 01:53:43.504390'),
(9,'auth','0007_alter_validators_add_error_messages','2020-06-12 01:53:43.512369'),
(10,'auth','0008_alter_user_username_max_length','2020-06-12 01:53:43.521345'),
(11,'auth','0009_alter_user_last_name_max_length','2020-06-12 01:53:43.530320'),
(12,'auth','0010_alter_group_name_max_length','2020-06-12 01:53:43.618087'),
(13,'auth','0011_update_proxy_permissions','2020-06-12 01:53:43.627062'),
(14,'users','0001_initial','2020-06-12 01:53:43.774666'),
(15,'admin','0001_initial','2020-06-12 01:53:44.355145'),
(16,'admin','0002_logentry_remove_auto_add','2020-06-12 01:53:44.510698'),
(17,'admin','0003_logentry_add_action_flag_choices','2020-06-12 01:53:44.521668'),
(18,'sessions','0001_initial','2020-06-12 01:53:44.562559'),
(19,'home','0001_initial','2020-06-13 00:21:52.194122'),
(20,'home','0002_article','2020-06-13 00:58:34.068000'),
(21,'home','0003_comment','2020-06-13 02:29:22.718955');
/*Table structure for table `django_session` */
DROP TABLE IF EXISTS `django_session`;
CREATE TABLE `django_session` (
`session_key` varchar(40) NOT NULL,
`session_data` longtext NOT NULL,
`expire_date` datetime(6) NOT NULL,
PRIMARY KEY (`session_key`),
KEY `django_session_expire_date_a5c62663` (`expire_date`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `django_session` */
/*Table structure for table `tb_article` */
DROP TABLE IF EXISTS `tb_article`;
CREATE TABLE `tb_article` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`avatar` varchar(100) NOT NULL,
`tags` varchar(20) NOT NULL,
`title` varchar(100) NOT NULL,
`summary` varchar(200) NOT NULL,
`content` longtext NOT NULL,
`total_view` int(10) unsigned NOT NULL,
`comments_count` int(10) unsigned NOT NULL,
`created` datetime(6) NOT NULL,
`updated` datetime(6) NOT NULL,
`author_id` int(11) NOT NULL,
`category_id` int(11) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `tb_article_author_id_dcf763a4_fk_tb_users_id` (`author_id`),
KEY `tb_article_category_id_d66932e8_fk_tb_category_id` (`category_id`),
CONSTRAINT `tb_article_author_id_dcf763a4_fk_tb_users_id` FOREIGN KEY (`author_id`) REFERENCES `tb_users` (`id`),
CONSTRAINT `tb_article_category_id_d66932e8_fk_tb_category_id` FOREIGN KEY (`category_id`) REFERENCES `tb_category` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=256 DEFAULT CHARSET=utf8;
/*Data for the table `tb_article` */
insert into `tb_article`(`id`,`avatar`,`tags`,`title`,`summary`,`content`,`total_view`,`comments_count`,`created`,`updated`,`author_id`,`category_id`) values
(1,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',23,1,'2020-06-13 01:10:45.554881','2020-06-13 10:05:50.434641',5,1),
(2,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',5,1,'2020-06-13 01:10:45.554881','2020-06-13 03:30:06.844569',5,1),
(3,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',2,0,'2020-06-13 01:10:45.554881','2020-06-13 03:02:19.220133',5,1),
(4,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(6,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',2,0,'2020-06-13 01:10:45.554881','2020-06-13 03:02:07.319324',5,1),
(7,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',1,0,'2020-06-13 01:10:45.554881','2020-06-13 02:21:45.344931',5,1),
(8,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(9,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',1,0,'2020-06-13 01:10:45.554881','2020-06-13 03:02:10.204711',5,1),
(13,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(14,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',1,0,'2020-06-13 01:10:45.554881','2020-06-13 03:02:13.375081',5,1),
(15,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(16,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(17,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(18,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(19,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(20,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(28,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(29,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(30,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',1,0,'2020-06-13 01:10:45.554881','2020-06-13 10:02:27.429521',5,1),
(31,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(32,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(33,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(34,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(35,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(36,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(37,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(38,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(39,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(40,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(41,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(42,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(43,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(59,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(60,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(61,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(62,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(63,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(64,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(65,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(66,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(67,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(68,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(69,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(70,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(71,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(72,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(73,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(74,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(75,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(76,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(77,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(78,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(79,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(80,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(81,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(82,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(83,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(84,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(85,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(86,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(87,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(88,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(89,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(90,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(122,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(123,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(124,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(125,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(126,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(127,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(128,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(129,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(130,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(131,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(132,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(133,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(134,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(135,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(136,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(137,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(138,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(139,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(140,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(141,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(142,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(143,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(144,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(145,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(146,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(147,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(148,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(149,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(150,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(151,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(152,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(153,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(154,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(155,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(156,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(157,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(158,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(159,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(160,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(161,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(162,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(163,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(164,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(165,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(166,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(167,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(168,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(169,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(170,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(171,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(172,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(173,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(174,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(175,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(176,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(177,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(178,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(179,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(180,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(181,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(182,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(183,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(184,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(185,'article/20200613/default-thumb.png','变量','Java类的初始化、变量的初始化','介绍 Java 的初始化成员变量','<p>变量的初始bai化：<br />\r\n1、整数类型（byte、short、int、long）的基本类du型变量的默认值为0。zhi<br />\r\n2、单精度浮点型（daofloat）的基本类型变量的默认值为0.0f。<br />\r\n3、双精度浮点型（double）的基本类型变量的默认值为0.0d。<br />\r\n4、字符型（char）的基本类型变量的默认为 “/u0000”。<br />\r\n5、布尔性的基本类型变量的默认值为 false。<br />\r\n6、引用类型的变量是默认值为 null。<br />\r\n类的初始化：如果当前想在B类中初始化一个A类，那么直接在B类中“A a =new A();”，此时a就是实例化了一个A类。之后a就拥有了A类中所有的非private属性。之后通过“a.setName()”等赋值方法来进行对象的赋值即可</p>\r\n',0,0,'2020-06-13 01:10:45.554881','2020-06-13 01:10:45.558872',5,1),
(249,'article/20200613/下载.jfif','爬虫','Python爬虫','介绍 Python 的爬虫','<p>Python 爬虫架构主要由五个部分组成，分别是调度器、URL管理器、网页下载器、网页解析器、应用程序（爬取的有价值数据）。</p>\r\n\r\n<ul>\r\n <li><strong>调度器：</strong>相当于一台电脑的CPU，主要负责调度URL管理器、下载器、解析器之间的协调工作。</li>\r\n <li><strong>URL管理器：</strong>包括待爬取的URL地址和已爬取的URL地址，防止重复抓取URL和循环抓取URL，实现URL管理器主要用三种方式，通过内存、数据库、缓存数据库来实现。</li>\r\n <li><strong>网页下载器：</strong>通过传入一个URL地址来下载网页，将网页转换成一个字符串，网页下载器有urllib2（Python官方基础模块）包括需要登录、代理、和cookie，requests(第三方包)</li>\r\n <li><strong>网页解析器：</strong>将一个网页字符串进行解析，可以按照我们的要求来提取出我们有用的信息，也可以根据DOM树的解析方式来解析。网页解析器有正则表达式（直观，将网页转成字符串通过模糊匹配的方式来提取有价值的信息，当文档比较复杂的时候，该方法提取数据的时候就会非常的困难）、html.parser（Python自带的）、beautifulsoup（第三方插件，可以使用Python自带的html.parser进行解析，也可以使用lxml进行解析，相对于其他几种来说要强大一些）、lxml（第三方插件，可以解析 xml 和 HTML），html.parser 和 beautifulsoup 以及 lxml 都是以 DOM 树的方式进行解析的。</li>\r\n <li><strong>应用程序：</strong>就是从网页中提取的有用数据组成的一个应用。</li>\r\n</ul>\r\n',5,0,'2020-06-13 03:29:02.877766','2020-06-13 10:11:37.279525',4,2),
(250,'article/20200613/20200510163200676.png','垃圾回收','Python垃圾回收机制','Python垃圾回收 引用计数器为主 标记清除和分代回收为辅 + 缓存机制','<p>在python中维护了一个refchain的双向环状链表，这个链表中存储程序创建的所有对象，每种类型的对象都有一个ob_refcnt引用计数器的值，当引用计数器变为0时会进行垃圾回收（对象销毁、refchain中移出）。</p>\r\n\r\n<p>但是，在python中对于那些可以有多个元素组成的对象可能会存在循环引用的问题，为了解决这个问题，python又引入了标记清除和分代回收，在其内部维护了4个链表，分别为：</p>\r\n\r\n<p>refchain</p>\r\n\r\n<ul>\r\n <li>2代</li>\r\n <li>1代</li>\r\n <li>0代</li>\r\n</ul>\r\n\r\n<p>在源码内部，当达到各自的阈值时，就会触发扫描链表进行标记清除的动作（有循环引用则各自-1）。</p>\r\n\r\n<p>But，源码内部在上述流程中提出了优化机制。</p>\r\n',21,2,'2020-06-13 09:54:39.915714','2020-06-13 10:11:05.097619',6,2),
(251,'article/20200613/20200518090836549.png','登陆','Python+Django+Vue实现登录注册功能','开发模式 前后端不分离 后端框架 Django + Jinja2模板引擎 前端框架 Vue.js','<p>2. 项目开发模式<br />\r\n开发模式 前后端不分离<br />\r\n后端框架 Django + Jinja2模板引擎<br />\r\n前端框架 Vue.js</p>\r\n\r\n<p>3. 准备项目代码仓库<br />\r\n1.源码托管网站<br />\r\n1、码云（https://gitee.com/）<br />\r\n2、创建源码远程仓库：website<br />\r\n3、克隆项目代码仓库 新建文件夹 下载git https://git-scm.com/download/win<br />\r\n按默认方式安装。克隆项目：git clone https://gitee.com/lgc1286191951/website.git<br />\r\n2.创建项目工程<br />\r\n1.进入本地项目仓库</p>\r\n\r\n<p>$ cd website<br />\r\n2.创建美多商城虚拟环境，安装Django框架<br />\r\n$ mkvirtualenv -p python3 website<br />\r\n$ pip install django<br />\r\n3.创建Django工程<br />\r\n$ django-admin startproject website<br />\r\n创建工程完成后：运行程序，测试结果。</p>\r\n\r\n<p>4.配置MySQL数据库<br />\r\n1. 新建MySQL数据库<br />\r\n1.新建MySQL数据库：test<br />\r\n$ create database meiduo charset=utf8;<br />\r\n2.新建MySQL用户</p>\r\n\r\n<p>$ create user test identified by ‘123456’;</p>\r\n\r\n<p>2. 配置MySQL数据库<br />\r\nDATABASES = {<br />\r\n‘default’: {<br />\r\n‘ENGINE’: ‘django.db.backends.mysql’, # 数据库引擎<br />\r\n‘HOST’: ‘127.0.0.1’, # 数据库主机<br />\r\n‘PORT’: 3306, # 数据库端口<br />\r\n‘USER’: ‘root’, # 数据库用户名root<br />\r\n‘PASSWORD’: ‘123456’, # 数据库用户密码<br />\r\n‘NAME’: ‘test’ # 数据库名字<br />\r\n},<br />\r\n}<br />\r\n可能出现的错误</p>\r\n\r\n<p>Error loading MySQLdb module: No module named ‘MySQLdb’.<br />\r\n出现错误的原因：</p>\r\n\r\n<p>Django中操作MySQL数据库需要驱动程序MySQLdb<br />\r\n目前项目虚拟环境中没有驱动程序MySQLdb<br />\r\n解决办法：</p>\r\n\r\n<p>安装PyMySQL扩展包<br />\r\n因为MySQLdb只适用于Python2.x的版本，Python3.x的版本中使用PyMySQL替代MySQLdb</p>\r\n',1,0,'2020-06-13 09:55:53.955748','2020-06-13 10:02:46.203348',6,2),
(252,'article/20200613/20200610143950492.png','js基础','JavaScript5种对象的命名属性创建(含测试源码)','本博文源于js基础，主要探讨对象的五种创建方式。分别是：花括号创建、使用点操作符创建、Object的create方法、Object的create方法、Object的defineProperty、defineProperties方法还有通过prototype属性创建。','<p>使用花括号创建<br />\r\n这种方式可类比成java的创建方式。看一个例子就能加深影响：</p>\r\n\r\n<p><script><br />\r\n var obj = {<br />\r\n v;1.0,<br />\r\n getV:function() {<br />\r\n return this.v;<br />\r\n },<br />\r\n _name:"object",<br />\r\n get name() {<br />\r\n this._name;<br />\r\n }<br />\r\n set name(name){<br />\r\n this._name = name;<br />\r\n }<br />\r\n } <br />\r\n</script><br />\r\n这里包含直接属性(v)、function对象属性(getV)以及访问器属性(name).</p>\r\n\r\n<p>使用点操作符创建<br />\r\n这种我们在其他面向对象的语言中经常使用，只需一个例子点名就行：</p>\r\n\r\n<p>var person = {name:"张三"};<br />\r\nperson.name = "李四";<br />\r\nperson.age = 88;<br />\r\n创建属性，定义属性赋值，如果之前有属性那就修改，如果没有那就添加相应的属性。</p>\r\n\r\n<p>Object的create方法<br />\r\n这个前面讲过，可以参考这篇博文：<br />\r\njs|3种方式创建object类型对象(含测试源码)。这种方式有两个参数，第一个参数中的属性为创建的对象[[Prototype]]属性，第二个参数为属性描述对象。</p>\r\n\r\n<p>Object的defineProperty、defineProperties方法<br />\r\n我们可以使用Object的defineProperty和defineProperties方法给对象添加属性。defineProperty方法可添加单个属性，defineProperties方法可以添加多个属性。<br />\r\nObject的defineProperty方法一共有三个参数，第一个是要添加属性的对象，第二个是要添加属性的属性名，第三个是属性的描述。先看其使用方式</p>\r\n\r\n<p><script><br />\r\n var obj = {};<br />\r\n Object.defineProperty(obj,"color",{<br />\r\n enumerable:true,<br />\r\n value:"green"<br />\r\n });<br />\r\n console.log(Object.getOwnPropertyNames(obj));<br />\r\n console.log(obj.color);<br />\r\n</script></p>\r\n\r\n<p>例子中使用defineProperty方法给obj对象添加了color属性。<br />\r\nObject的defineProperties方法可以创建多个属性，它有两个参数，第一个参数是要添加属性的对象，第二个参数是属性描述对象，和create方法中的第二个参数一样，例如下面</p>\r\n\r\n<p><script><br />\r\n var obj = {};<br />\r\n Object.defineProperties(obj,{<br />\r\n name:{<br />\r\n enumerable:true,<br />\r\n writable:false,<br />\r\n value:"lucy"<br />\r\n },<br />\r\n color: {<br />\r\n enumerable:true;<br />\r\n value:"green"<br />\r\n }<br />\r\n });<br />\r\n console.log(Object.getOwnPropertyNames(obj));<br />\r\n obj.name = "peter";<br />\r\n console.log(obj,name);<br />\r\n</script</p>\r\n\r\n<p>这个例子使用Object的defineProperties方法给obj对象添加了name和color两个属性。在这个例子种，因为name属性的writable为false，所以obj的name属性不可以修改，因此打印lucy。</p>\r\n\r\n<p>通过prototype属性创建<br />\r\n关于prototype属性，专门一篇博文谈这个<br />\r\nJavaScript|1篇博文探寻prototype属性与继承<br />\r\n因为此属性function对象的prototype中的属性并不会添加到创建的实例对象中，但创建的对象可以调用，这样就相当于可以将prototype中的属性添加到创建的对象中。 也可以看个例子：</p>\r\n\r\n<p><script><br />\r\n function Shop(){}<br />\r\n var shop = new Shop();<br />\r\n Shop.prototype.type = "网络销售";<br />\r\n console.log(shop.type);<br />\r\n</script></p>\r\n',12,0,'2020-06-13 09:57:52.953489','2020-06-13 10:11:59.238801',6,3),
(253,'article/20200613/2020051719274449.png','学习笔记','MySQL 学习记录系列（四）','对于访问数据库来说，建立连接的代价是比较昂贵的，因为频繁的创建关闭连接，是比较耗费资源的，因此有必要建立数据库连接池，以提高访问的性能。','<p>1.2、减少对MySQL的访问<br />\r\n1.2.1、避免对数据进行重复检索</p>\r\n\r\n<p>在编写应用代码时，需要能够理清对数据库的访问逻辑。能够一次连接就获取到结果的，就不用两次连接，这样可以大大减少对数据库无用的重复请求。</p>\r\n\r\n<p>比如，需要获取书籍的id和name字段，则查询如下：</p>\r\n\r\n<p>select id，name from tb_book；</p>\r\n\r\n<p>之后，在业务逻辑中有需要获取到书籍状态信息，则查询如下：</p>\r\n\r\n<p>select id，status from tb_book；</p>\r\n\r\n<p>1.2.2、增加cache层</p>\r\n\r\n<p>可以在应用中增加缓存层来达到减轻数据库负担的目的。缓存层有很多种，也有很多实现方式，只要能达到降低数据库的负担又能满足应用需求就可以。</p>\r\n\r\n<p>因此可以部分数据从数据库中抽取出来放到应用端以文本方式存储，或者使用框架（Mybatis，Hibernate）提供的一级缓存/二级缓存，或者使用redis数据库来缓存数据。</p>\r\n\r\n<p>1.3、负载均衡<br />\r\n负载均衡是应用中使用非常普遍的一种优化方法，它的机制就是利用某种均衡算法，将固定的负载量分布到不同的服务器上，以此来降低单台服务器的负载，达到优化的效果。</p>\r\n\r\n<p>1.3.1、利用MySQL复制分流查询</p>\r\n\r\n<p>通过MySQL的主从复制，实现读写分离，使增删改操作走主节点，查询操作走从节点，从而可以降低单台服务器的读写压力。</p>\r\n\r\n<p>1.3.2、采用分布式数据库架构</p>\r\n\r\n<p>分布式数据库架构适合大数据量、负载高的情况，它有良好的拓展性和高可用性。通过在多台服务器之间分布数据，可以实现在多台服务器之间的负载均衡，提高访问效率。</p>\r\n\r\n<p>2.Mysql中查询缓存优化<br />\r\n2.1、概述<br />\r\n开启Mysq的查询缓存，当执行完全相同的SQL语句的时候，服务器就会直接从缓存中读取结果，当数据被修改，之前的缓存会失效，修改比较频繁的表不适合做查询缓存。</p>\r\n\r\n<p>2.2、操作流程</p>\r\n\r\n<p>1.客户端发送一条查询给服务器；</p>\r\n\r\n<p>2.服务器先会检查查询缓存，如果命中了缓存，则立即返回存储在缓存中的结果。否则进入下一阶段；</p>\r\n\r\n<p>3.服务器端进行SQL解析、预处理，再由优化器生成对应的执行计划；</p>\r\n\r\n<p>4.MySQL根据优化器生成的执行计划，调用存储引擎的API来执行查询；</p>\r\n\r\n<p>5.将结果返回给客户端。</p>\r\n',6,0,'2020-06-13 09:59:33.988374','2020-06-13 10:11:24.109746',6,4),
(254,'article/20200613/20150126110634828.png','基础知识','计算机网络基本知识汇总','常用的 HTTP 请求方法有GET、POST、HEAD、PUT、DELETE、OPTIONS、TRACE、CONNECT;','<p>常用的 HTTP 请求方法有GET、POST、HEAD、PUT、DELETE、OPTIONS、TRACE、CONNECT;</p>\r\n\r\n<p>GET：当客户端要从服务器中读取某个资源时，使用GET 方法。GET 方法要求服务器将URL 定位的资源放在响应报文的部分，回送给客户端，即向服务器请求某个资源。使用GET 方法时，请求参数和对应的值附加在 URL 后面，利用一个问号(“?”)代表URL 的结尾与请求参数的开始，传递参数长度受限制。例如，/index.jsp?id=100&op=bind。</p>\r\n\r\n<p>POST：当客户端给服务器提供信息较多时可以使用POST 方法，POST 方法向服务器提交数据，比如完成表单数据的提交，将数据提交给服务器处理。GET 一般用于获取/查询资源信息，POST 会附带用户数据，一般用于更新资源信息。POST 方法将请求参数封装在HTTP 请求数据中，以名称/值的形式出现，可以传输大量数据;</p>\r\n\r\n<p>请求头部：请求头部由关键字/值对组成，每行一对，关键字和值用英文冒号“:”分隔。请求头部通知服务器有关于客户端请求的信息，典型的请求头有：</p>\r\n\r\n<p>User-Agent：产生请求的浏览器类型;<br />\r\nAccept：客户端可识别的响应内容类型列表;星号 “ * ” 用于按范围将类型分组，用 “ / ” 指示可接受全部类型，用“ type/* ”指示可接受 type 类型的所有子类型;<br />\r\nAccept-Language：客户端可接受的自然语言;<br />\r\nAccept-Encoding：客户端可接受的编码压缩格式;<br />\r\nAccept-Charset：可接受的应答的字符集;<br />\r\nHost：请求的主机名，允许多个域名同处一个IP 地址，即虚拟主机;<br />\r\nconnection：连接方式(close 或 keepalive);<br />\r\nCookie：存储于客户端扩展字段，向同一域名的服务端发送属于该域的cookie;</p>\r\n\r\n<p>状态码由三位数字组成，第一位数字表示响应的类型，常用的状态码有五大类如下所示：</p>\r\n\r\n<p>1xx：表示服务器已接收了客户端请求，客户端可继续发送请求;<br />\r\n2xx：表示服务器已成功接收到请求并进行处理;<br />\r\n3xx：表示服务器要求客户端重定向;<br />\r\n4xx：表示客户端的请求有非法内容;<br />\r\n5xx：表示服务器未能正常处理客户端的请求而出现意外错误;<br />\r\n200 OK：表示客户端请求成功;</p>\r\n\r\n<p>400 Bad Request：表示客户端请求有语法错误，不能被服务器所理解;</p>\r\n\r\n<p>401 Unauthonzed：表示请求未经授权，该状态代码必须与 WWW-Authenticate 报头域一起使用;</p>\r\n\r\n<p>403 Forbidden：表示服务器收到请求，但是拒绝提供服务，通常会在响应正文中给出不提供服务的原因;</p>\r\n\r\n<p>404 Not Found：请求的资源不存在，例如，输入了错误的URL;</p>\r\n\r\n<p>500 Internal Server<br />\r\nError：表示服务器发生不可预期的错误，导致无法完成客户端的请求;</p>\r\n\r\n<p>503 Service Unavailable：表示服务器当前不能够处理客户端的请求，在一段时间之后，服务器可能会恢复正常;</p>\r\n\r\n<p>响应头部：响应头可能包括：<br />\r\n- Location：Location响应报头域用于重定向接受者到一个新的位置。例如：客户端所请求的页面已不存在原先的位置，为了让客户端重定向到这个页面新的位置，服务器端可以发回Location响应报头后使用重定向语句，让客户端去访问新的域名所对应的服务器上的资源;<br />\r\n- Server：Server 响应报头域包含了服务器用来处理请求的软件信息及其版本。它和 User-Agent 请求报头域是相对应的，前者发送服务器端软件的信息，后者发送客户端软件(浏览器)和操作系统的信息。<br />\r\n- Vary：指示不可缓存的请求头列表;<br />\r\n- Connection：连接方式;</p>\r\n\r\n<p>对于请求来说：close(告诉WEB 服务器或者代理服务器，在完成本次请求的响应后，断开连接，不等待本次连接的后续请求了)。keepalive(告诉WEB服务器或者代理服务器，在完成本次请求的响应后，保持连接，等待本次连接的后续请求);</p>\r\n\r\n<p>对于响应来说：close(连接已经关闭); keepalive(连接保持着，在等待本次连接的后续请求); Keep-Alive：如果浏览器请求保持连接，则该头部表明希望WEB 服务器保持连接多长时间(秒);例如：Keep-Alive：300;</p>\r\n\r\n<p>WWW-Authenticate：WWW-Authenticate响应报头域必须被包含在401 (未授权的)响应消息中，这个报头域和前面讲到的Authorization 请求报头域是相关的，当客户端收到 401 响应消息，就要决定是否请求服务器对其进行验证。如果要求服务器对其进行验证，就可以发送一个包含了Authorization 报头域的请求;<br />\r\n问题：<br />\r\n1. Http1.1与Http1.0的区别<br />\r\nhttp1.0使用非持久连接（短连接），而http1.1默认是持久连接（长连接），当然也可以配置成非持久连接。</p>\r\n',5,0,'2020-06-13 10:01:56.386535','2020-06-13 10:11:31.850046',6,5),
(255,'article/20200613/20180508124331188','基础','零基础学习PHP编程——认识程序和编程语言','本文主要写给零基础的同学，作为编程的入门引导, 如有不当之处，还请指正。','<p>回顾上一节，我们已经知道计算机的一些基本概念了，如硬件系统及其组成，操作系统和应用程序等，本小节主要想讲明白什么是程序，什么是程序语言，以及高级语言的一些特点。</p>\r\n\r\n<p>一、 什么是计算机程序？</p>\r\n\r\n<table border=\"1\" cellpadding=\"1\" cellspacing=\"1\" style=\"width:500px\" summary=\"看一下\">\r\n <caption>测试表格</caption>\r\n <tbody>\r\n <tr>\r\n <td>1</td>\r\n <td>1</td>\r\n </tr>\r\n <tr>\r\n <td>2</td>\r\n <td>2</td>\r\n </tr>\r\n <tr>\r\n <td>3</td>\r\n <td>4</td>\r\n </tr>\r\n </tbody>\r\n</table>\r\n\r\n<p><br />\r\n摘一段百科上的描述： 计算机程序（Computer program），也称为软件（software），简称程序（Program），是指一组指示计算机或其他具有信息处理能力装置每一步动作的指令，通常用某种程序设计语言编写，运行于某种目标体系结构上。</p>\r\n\r\n<p>通俗的理解计算机程序</p>\r\n\r\n<p>计算机程序，就是运行在计算机上能完成特定功能的指令集合，计算机程序的复杂程度由所需完成的逻辑功能来决定，计算机程序有简单的也有复杂的，如编写简单的程序可以计算一个一元二次方程方程的解，而一个功能强大的游戏程序，可以给你带来不一样的游戏体验，程序的本质就是运行在计算机之上的一组有序指令的集合，这些指令可以让计算机执行一些具体的运算，能实现特定的功能。</p>\r\n\r\n<p>在计算机开机后，进入操作系统如Windows/Linux/Mac等，操作系统会加载并执行许多程序，操作系统本质也是由一组计算机程序组成的，通常意义上表述的计算机程序，一般指的是能完成某些特定功能，相对比较独立的程序，如视频/音频播放器，Web浏览器，社交工具的客户端Wechat/QQ等；而一般由许多计算机程序共同协作来完成比较复杂的任务的一系列程序，通常被称为系统，如操作系统等。</p>\r\n\r\n<p>百科描述中所说的指令运行于某种目标体系结构上，对于绝大多数计算机来说，从计算机体系结构的大分类来看，这里的目标体系结构通常都是指最常见的冯诺依曼体系结构，也就是上一节所讲述计算机的基本结构，而在冯诺依曼体系结构设计之下，CPU（运算器和控制器）的设计也可以划分不同的体系结构。</p>\r\n\r\n<p>再了解一下什么是指令集，指令集是存储在CPU内部，对CPU运算进行指导和优化的硬程序，也就是说CPU的运算器只能执行CPU的指令集体系所支持的指令，之所以出现不同的CPU架构，就是由于指令集的设计不同，常见的CPU架构有Intel公司的X86架构和ARM公司的ARM架构，对应的指令集分别为复杂指令集(CISC)和精简指令集(RISC)， X86和ARM处理器的主要区别就是，前者使用复杂指令集(CISC)，而后者使用精简指令集(RISC)。X86架构的CPU常见于笔记本、台式机和服务器上，而ARM架构的CPU多用于手机及嵌入式系统里，指令集的细分类型还有许多，感兴趣的可以具体了解一下。</p>\r\n\r\n<p><br />\r\n二、 什么是程序语言？</p>\r\n\r\n<p>上面讲述了什么是计算机程序，计算机程序的本质就是运行在某种目标体系结构（可暂且理解为某种CPU架构）上面的指令集合，而这些指令的集合都应该能被该CPU架构所支持，即该CPU的运算器可以执行该指令集合中的所有指令，也就是说在不同的CPU架构上编写相同功能的程序，最后生成的该程序所对应的指令集合很可能是不一样的。</p>\r\n\r\n<p>1. 机器语言</p>\r\n\r\n<p>通过CPU架构所支持的指令集可以编写出成千上万的程序，而由指令集所组成的程序，可以被CPU直接解读和执行， 由指令集生成程序的过程就如同，通过文字去编写文章，单个的字或词就是某一条具体的指令，不同字或词(指令)通过一定规则组合起来，就是一篇文章(程序)，所以CPU架构所支持的指令集的体系，也可以看做是一门语言，这门语言就是通常所说的机器语言，又称为机器码。不同的CPU架构所支持的不同指令集可以看做是不同的机器语言，就如同文字也分为汉语、English等许多语言，机器语言的道理也一样。</p>\r\n\r\n<p>2. 汇编语言</p>\r\n\r\n<p>通过机器语言就可以编写出许多各种功能的程序了，但是用机器语言编写程序，编程人员要首先熟记所用计算机的全部指令代码和代码的涵义，手编程序时，程序员还需要自己处理每条指令和每一数据的存储分配和输入输出，还得记住编程过程中每步所使用的工作单元处在何种状态。这是一件十分繁琐的工作。编写程序花费的时间往往是实际运行时间的几十倍甚至几百倍，而且，编出的程序全是些0和1的指令代码，直观性差，还容易出错，那该怎么办了？</p>\r\n\r\n<p>这时候汇编语言便产生了，汇编语言的主体是汇编指令。汇编指令和机器指令的差别在于指令的表示方法上，汇编指令是机器指令便于记忆的书写格式，如执行一个操作：寄存器BX的内容送到AX中(具体什么含义可以不用深究，明白是一条完成特定功能的指令即可)</p>\r\n\r\n<p> 1000100111011000 机器指令<br />\r\n mov ax,bx 汇编指令</p>\r\n\r\n<p>很容易可以看出，同样一个操作，下面的汇编指令更容易被人熟记，汇编语言的出现是程序发展的一大进步，相比机器语言主要有以下几个特点：</p>\r\n\r\n<p>1. 更具有可编程性，即使用汇编语言，程序员可以更加简便、更加快速、更容易理解的方式完成同样的编程任务；</p>\r\n\r\n<p>2. 程序可移植性，上文介绍过不同的CPU架构支持不同的指令集体系(机器语言)，所以通常以机器语言为某一类CPU架构编写的程序，不能运行在其它CPU架构之上，而有了汇编语言，可以想象同样一条汇编语句，运行在不同的CPU架构上时，只需要编译器把它编译(就如不同语言文字之间的翻译)成对应CPU架构所支持的机器码即可；</p>\r\n\r\n<p>汇编语言的编译器，是可以把汇编语言翻译成目标CPU架构上机器语言的程序。</p>\r\n',0,0,'2020-06-13 10:10:02.336449','2020-06-13 10:10:02.337420',6,6);
/*Table structure for table `tb_category` */
DROP TABLE IF EXISTS `tb_category`;
CREATE TABLE `tb_category` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`title` varchar(100) NOT NULL,
`created` datetime(6) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
/*Data for the table `tb_category` */
insert into `tb_category`(`id`,`title`,`created`) values
(1,'Java','2020-06-13 00:31:00.000000'),
(2,'Python','2020-06-13 00:31:00.000000'),
(3,'JavaScript','2020-06-13 00:31:00.000000'),
(4,'MySQL','2020-06-13 00:32:00.000000'),
(5,'计算机网络','2020-06-13 00:32:00.000000'),
(6,'PHP','2020-06-13 00:32:00.000000');
/*Table structure for table `tb_comment` */
DROP TABLE IF EXISTS `tb_comment`;
CREATE TABLE `tb_comment` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`content` longtext NOT NULL,
`created` datetime(6) NOT NULL,
`article_id` int(11) DEFAULT NULL,
`user_id` int(11) DEFAULT NULL,
PRIMARY KEY (`id`),
KEY `tb_comment_article_id_d3d5d1ea_fk_tb_article_id` (`article_id`),
KEY `tb_comment_user_id_905a9388_fk_tb_users_id` (`user_id`),
CONSTRAINT `tb_comment_article_id_d3d5d1ea_fk_tb_article_id` FOREIGN KEY (`article_id`) REFERENCES `tb_article` (`id`),
CONSTRAINT `tb_comment_user_id_905a9388_fk_tb_users_id` FOREIGN KEY (`user_id`) REFERENCES `tb_users` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=16 DEFAULT CHARSET=utf8;
/*Data for the table `tb_comment` */
insert into `tb_comment`(`id`,`content`,`created`,`article_id`,`user_id`) values
(1,'<p>测试一下评论</p>\r\n','2020-06-13 02:43:27.173089',1,4),
(2,'<p>测试一下评论</p>\r\n','2020-06-13 02:43:27.173089',1,4),
(3,'<p>测试一下评论</p>\r\n','2020-06-13 02:43:27.173089',1,4),
(4,'<p>测试一下评论</p>\r\n','2020-06-13 02:43:27.173089',1,4),
(6,'<p>测试一下评论</p>\r\n','2020-06-13 02:43:27.173089',1,4),
(7,'<p>测试一下评论</p>\r\n','2020-06-13 02:43:27.173089',1,4),
(8,'<p>测试一下评论</p>\r\n','2020-06-13 02:43:27.173089',1,4),
(9,'<p>测试一下评论</p>\r\n','2020-06-13 02:43:27.173089',1,4),
(13,'<p>第二条文章评论</p>\r\n','2020-06-13 03:29:57.850640',2,4),
(14,'<p>嗯，还不错。</p>\r\n','2020-06-13 10:10:40.430552',250,6),
(15,'<p>鸭鸭亚</p>\r\n','2020-06-13 10:10:53.323109',250,6);
/*Table structure for table `tb_users` */
DROP TABLE IF EXISTS `tb_users`;
CREATE TABLE `tb_users` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`password` varchar(128) NOT NULL,
`last_login` datetime(6) DEFAULT NULL,
`is_superuser` tinyint(1) NOT NULL,
`username` varchar(150) NOT NULL,
`first_name` varchar(30) NOT NULL,
`last_name` varchar(150) NOT NULL,
`email` varchar(254) NOT NULL,
`is_staff` tinyint(1) NOT NULL,
`is_active` tinyint(1) NOT NULL,
`date_joined` datetime(6) NOT NULL,
`mobile` varchar(11) NOT NULL,
`avatar` varchar(100) NOT NULL,
`user_desc` varchar(500) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `username` (`username`),
UNIQUE KEY `mobile` (`mobile`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8;
/*Data for the table `tb_users` */
insert into `tb_users`(`id`,`password`,`last_login`,`is_superuser`,`username`,`first_name`,`last_name`,`email`,`is_staff`,`is_active`,`date_joined`,`mobile`,`avatar`,`user_desc`) values
(4,'pbkdf2_sha256$180000$fAJlaqDtvFZ8$TtOPUtpr+4cmOwczOM+EUBzW5+iYFYdOvuzUh//NKfs=','2020-06-13 03:03:17.907332',0,'17858918830','','','',0,1,'2020-06-12 12:38:30.028839','17858918830','avatar/20200613/toux.jpg','我是王硕，这是我的个人博客。'),
(5,'pbkdf2_sha256$180000$H5xw4oRroPSO$qWorgMONgxKOBw8J5m8ESsMPkhAhD5CRGr9sOmckyeU=','2020-06-13 10:18:34.718711',1,'wangshuo','','','wangsuoo@qq.com',1,1,'2020-06-13 00:24:36.558518','17858918831','',''),
(6,'pbkdf2_sha256$180000$fAJlaqDtvFZ8$TtOPUtpr+4cmOwczOM+EUBzW5+iYFYdOvuzUh//NKfs=','2020-06-13 09:48:28.270574',0,'test','wang','shuo','wangsuoo@qq.com',0,1,'2020-06-13 11:35:16.000000','17858918832','avatar/20200613/toux.jpg','这是一个测试用户');
/*Table structure for table `tb_users_groups` */
DROP TABLE IF EXISTS `tb_users_groups`;
CREATE TABLE `tb_users_groups` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`user_id` int(11) NOT NULL,
`group_id` int(11) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `tb_users_groups_user_id_group_id_5a177a84_uniq` (`user_id`,`group_id`),
KEY `tb_users_groups_group_id_04d64563_fk_auth_group_id` (`group_id`),
CONSTRAINT `tb_users_groups_group_id_04d64563_fk_auth_group_id` FOREIGN KEY (`group_id`) REFERENCES `auth_group` (`id`),
CONSTRAINT `tb_users_groups_user_id_5f9e3ed0_fk_tb_users_id` FOREIGN KEY (`user_id`) REFERENCES `tb_users` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `tb_users_groups` */
/*Table structure for table `tb_users_user_permissions` */
DROP TABLE IF EXISTS `tb_users_user_permissions`;
CREATE TABLE `tb_users_user_permissions` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`user_id` int(11) NOT NULL,
`permission_id` int(11) NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `tb_users_user_permissions_user_id_permission_id_064c2ef6_uniq` (`user_id`,`permission_id`),
KEY `tb_users_user_permis_permission_id_b9b3ac94_fk_auth_perm` (`permission_id`),
CONSTRAINT `tb_users_user_permis_permission_id_b9b3ac94_fk_auth_perm` FOREIGN KEY (`permission_id`) REFERENCES `auth_permission` (`id`),
CONSTRAINT `tb_users_user_permissions_user_id_2726c819_fk_tb_users_id` FOREIGN KEY (`user_id`) REFERENCES `tb_users` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
/*Data for the table `tb_users_user_permissions` */
/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手
