lorch.github.io/atom.xml at master · lorch/lorch.github.io

History

3103 lines (1987 loc) · 108 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

645

646

647

648

649

650

651

652

653

654

655

656

657

658

659

660

661

662

663

664

665

666

667

668

669

670

671

672

673

674

675

676

677

678

679

680

681

682

683

684

685

686

687

688

689

690

691

692

693

694

695

696

697

698

699

700

701

702

703

704

705

706

707

708

709

710

711

712

713

714

715

716

717

718

719

720

721

722

723

724

725

726

727

728

729

730

731

732

733

734

735

736

737

738

739

740

741

742

743

744

745

746

747

748

749

750

751

752

753

754

755

756

757

758

759

760

761

762

763

764

765

766

767

768

769

770

771

772

773

774

775

776

777

778

779

780

781

782

783

784

785

786

787

788

789

790

791

792

793

794

795

796

797

798

799

800

801

802

803

804

805

806

807

808

809

810

811

812

813

814

815

816

817

818

819

820

821

822

823

824

825

826

827

828

829

830

831

832

833

834

835

836

837

838

839

840

841

842

843

844

845

846

847

848

849

850

851

852

853

854

855

856

857

858

859

860

861

862

863

864

865

866

867

868

869

870

871

872

873

874

875

876

877

878

879

880

881

882

883

884

885

886

887

888

889

890

891

892

893

894

895

896

897

898

899

900

901

902

903

904

905

906

907

908

909

910

911

912

913

914

915

916

917

918

919

920

921

922

923

924

925

926

927

928

929

930

931

932

933

934

935

936

937

938

939

940

941

942

943

944

945

946

947

948

949

950

951

952

953

954

955

956

957

958

959

960

961

962

963

964

965

966

967

968

969

970

971

972

973

974

975

976

977

978

979

980

981

982

983

984

985

986

987

988

989

990

991

992

993

994

995

996

997

998

999

1000

<?xml version="1.0" encoding="utf-8"?>

<id>https://lorch.github.io/</id>

</author>

<entry>

<id>https://lorch.github.io/14776756719530.html</id>

<content type="html"><![CDATA[

<h2 id="toc_0">第一段神奇的小代码</h2>

<pre><code class="language-java">import java.util.HashMap;

import java.util.Map;

/**

* Created by violorch on 16/10/29.

public class MapTest {

public static void main(String[] args) {

Map map1 = new HashMap();

map1.put("n1", 1);

Map<String, String> map2 = (Map)map1;

map2.put("n2", "2");

Map<String, String> map3 = new HashMap<String, String>();

map3.put("n3", "map3");

System.out.println("str_" + map3.get("n3"));

System.out.println("str_" + map2.get("n2"));

System.out.println("str_" + map2.get("n1"));

}

</code></pre>

<p>大家觉得这段代码会不会报错呢？<br/>

.<br/>.<br/>.<br/>.<br/>.<br/>.</p>

<p>答案就是：这段代码在编译期不会出现任何问题，但是在运行期会报错：</p>

<pre><code>java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String

at MapTest.main(MapTest.java:22)

at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)

at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)

at java.lang.reflect.Method.invoke(Method.java:497)

at com.intellij.rt.execution.application.AppMain.main(AppMain.java:144)

</code></pre>

<p>造成这个问题的原因，在上述结果来看，是一个Integer的值，躲过了编译期的检查，被put到了String类型里面。然后在运行期，被发现了。可是我们都知道，直接 <code>map2.put("number", 2)</code> 是不可能通过编译的。那么更深入的原因是什么呢？</p>

<p>先来看看编译后的<code>.class</code>文件：</p>

<pre><code>//

// Source code recreated from a .class file by IntelliJ IDEA

// (powered by Fernflower decompiler)

import java.util.HashMap;

public class MapTest {

public MapTest() {

}

public static void main(String[] args) {

HashMap map1 = new HashMap();

map1.put("n1", Integer.valueOf(1));

map1.put("n2", "2");

HashMap map3 = new HashMap();

map3.put("n3", "map3");

System.out.println("str_" + (String)map3.get("n3"));

System.out.println("str_" + (String)map1.get("n2"));

System.out.println("str_" + (String)map1.get("n1"));

}

</code></pre>

<p>可以看到，<code>Map<String,String></code> 和 <code>Map</code> 在被编译后，其实都是一种类型 <code>Map</code> ，这就是Java语言中泛型的实现方法 <strong>类型擦除</strong>。<br/>

在map1被赋值到map2的时候，编译器其实干了两件大事。第一件，就是类型擦除；第二件，就是优化了代码，省略了map2。<br/>

在干第一件大事儿的时候，由于编译器认为map1和map2是同一种类型，所以map1很轻松的就被赋值给了map2，这也就是编译期没有报错的原因。而在运行期，<code>(String)map1.get("n1")</code> 强转的时候，终于被发现了这个问题。<br/>

由上可知，在Java中的泛型，其实是一种语法糖。大家使用的时候，要小心类似的陷阱。</p>

<p><strong>需要注意的是</strong>，擦除法所谓的擦除，仅仅是对方法的Code属性中的字节码进行擦除，实际上元数据中还是保留了泛型信息，这也是我们能通过反射手段取得参数化类型的根本依据。<sup id="fnref1"><a href="#fn1" rel="footnote">1</a></sup> </p>

<hr/>

<ol>

<p>最后一句话引自《深入理解Java虚拟机·机械工业出版社》P315，第二段。 <a href="#fnref1" rev="footnote">↩</a></p>

</li>

</ol>

</div>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767976487467.html</id>

<content type="html"><![CDATA[

<ul>

<li><p>系统环境：OS X EI Capitan</p></li>

<li><p>JDK版本：java version "1.8.0_73"</p></li>

<li><p>hadoop版本：hadoop-3.0.0-alpha1</p></li>

</ul>

<ul>

<li><p>jdk下载地址：<a href="http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html">Java SE Development Kit 8</a></p></li>

<li><p>hadoop下载地址：<a href="http://hadoop.apache.org/releases.html#03+September%2C+2016%3A+Release+3.0.0-alpha1+available">hadoop-3.0.0-alpha1</a></p></li>

</ul>

<ul>

<li><a href="http://hadoop.apache.org/docs/current/hadoop-project-dist/hadoop-common/ClusterSetup.html">hadoop官网文档</a></li>

</ul>

<p>测试ssh 是否可以免密登录</p>

<pre><code>$ ssh localhost

</code></pre>

<p>如果不可以，执行以下操作：</p>

<pre><code>$ ssh-keygen -t dsa -P '' -f ~/.ssh/id_dsa

$ cat ~/.ssh/id_dsa.pub >> ~/.ssh/authorized_keys

$ chmod 0600 ~/.ssh/authorized_keys

</code></pre>

<h4 id="toc_5">解压下载的 <code>hadoop-3.0.0-alpha1.tar.gz</code></h4>

<pre><code class="language-sh">$ tar -zxf hadoop-3.0.0-alpha1.tar.gz

</code></pre>

<h4 id="toc_6">配置环境变量</h4>

<pre><code class="language-sh">$ vim ~/.bash_profile

# 在文件末尾添加

HADOOP_HOME=/Users/home/apache/hadoop-3.0.0-alpha1

JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_73.jdk/Contents/Home

PATH=$PATH:$JAVA_HOME/bin:$HADOOP_HOME/bin:$HADOOP_HOME/sbin

# 保存并离开

:wq

# 使修改后的文件生效

$ source ~/.bash_profile

</code></pre>

<h4 id="toc_7">修改hadoop配置文件</h4>

<pre><code>$ cd $HADOOP_HOME/etc/hadoop

</code></pre>

<ul>

</ul>

<name>fs.defaultFS</name>

<value>hdfs://localhost:9999</value>

</property>

</configuration>

</code></pre>

<ul>

</ul>

<name>dfs.namenode.name.dir</name>

<value>/Users/violorch/apache/hadoop-3.0.0-alpha1/hadoop_name/</value>

</property>

<name>dfs.datanode.name.dir</name>

<value>/Users/violorch/apache/hadoop-3.0.0-alpha1/hadoop_data/</value>

</property>

<name>dfs.replication</name>

</property>

</configuration>

</code></pre>

<h4 id="toc_8">格式化一个新的分布式文件系统</h4>

<pre><code>$ hdfs namenode -format

</code></pre>

<h4 id="toc_9">启动namenode和datanode守护进程</h4>

<pre><code>$ start-dfs.sh

</code></pre>

<h4 id="toc_10">终止namenode和datanode守护进程</h4>

<pre><code>$ stop-dfs.sh

</code></pre>

<p><a href="http://localhost:9870/">http://localhost:9870/</a></p>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767164878672.html</id>

<content type="html"><![CDATA[

<p>工欲善其事，必先利其器。所以Golang部署，是我的第一篇纪录.</p>

<p>部署环境：sublime2 ＋ mac</p>

</blockquote>

<h2 id="toc_0">下载Golang并安装</h2>

<ul>

<li>golang下载地址：<a href="http://golang.org/doc/install">戳我，我是地址君</a></li>

<li>选择对应的版本，这里我选的是：<code>go1.4.2.darwin-amd64-osx10.8.pkg</code></li>

<li>双击下载包，安装</li>

</ul>

<h2 id="toc_1">部署GoLang环境变量</h2>

<p>在mac中，打开iTerm输入 <code>vim ./bash_profig</code>，添加如下路径：</p>

<pre><code class="language-bash">⚠ 这是mac默认安装的所选择的路径，其他系统按照不同的安装路径,将GOROOT设置为不同值*

export GOROOT=/usr/local/Cellar/go/1.4/libexec/

export GOBIN=$GOROOT/bin

⚠ GOPATH有点儿特殊，是一个工作空间，一般一个GoLang应用有一个工作空间，多个路径之间的用:[mac,linux]连接[windows用; 这个跟path环境变量的多个链接相同]。

export GOPATH=/Users/YourGoPath

export PATH=$PATH:$GOBIN:$GOPATH

</code></pre>

<p>现在，在iTerm输入 <code>go version</code>, 应该可以看到Go的版本号的输出了。</p>

<h2 id="toc_2">配置sublime2上的Golang编写环境</h2>

<p>可以编译Go的编辑器有很多，IiteIDE， Goclipse，Vim， Emacs之类的都行，万能的Vim配好了其实也很好用，是大神利器。此外，个人感觉安装最便利的是Goclipse，使用最便利的是IiteIDE，毕竟这个是专为GoLang设计的忠犬，Emacs没有用过，据说是个大杀器。<br/>

但是这里我选择了sublime。原谅我是一个可耻的外卖协会，sublime的界面让我在写代码的时候感觉非常舒服，而且支持语法高亮，有点儿简陋的语义提示，此外，在保存的时候会自动矫正错误格式。<br/>

sublime几乎可以算得上的免费。试用无时间限制，但是时不时会提示你购买，偶尔会觉得这一点儿非常烦，可以找下破解，kill掉这个。</p>

<p>闲话到此，这里提供下sublime的官方下载地址：<a href="http://www.sublimetext.com/2">戳我，我是地址君</a></p>

<ul>

<li>选择合适自己的版本，双击安装。</li>

<li><p>打开sublime，安装GoSubLime插件</p>

<ul>

<li>按下<code>command＋shift＋p</code> [window用<code>ctrl＋shift＋p</code>]</li>

<li>输入<code>install</code>, 选择<code>install package</code>回车</li>

<li>在跳出的输入框中输入<code>GoSublime</code>, 选择<code>GoSublime</code>回车</li>

<li>输入<code>Go build</code>选中回车（这个属于可选）</li>

</ul>

</blockquote></li>

<li><p>下载GoCode，在iTerm中输入：</p></li>

</ul>

<pre><code class="language-bash">go get -u github.com/nsf/gocode

go install github.com/nsf/gocode

</code></pre>

<ul>

<li>修改sublime配置，选择菜单Preferences -> Package Settings -> Package Controll -> Settings-User。打开文件，配置如下：</li>

</ul>

<pre><code class="language-json">{

"in_process_packages":

[

"installed_packages":

[

"Go Build",

"GoSublime",

"Package Control"

]

}

</code></pre>

<p>重启之后，尝试编辑Go吧</p>

<p>⚠ 代码编写完成后，可以按command＋b呼出命令行</p>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767163933235.html</id>

<content type="html"><![CDATA[

<h2 id="toc_0">修改mac终端的提示前缀</h2>

<pre><code class="language-shell">$ sudo scutil --set HostName [你想要的新hostname]

</code></pre>

<h2 id="toc_1">安装apt-get</h2>

<pre><code class="language-shell">$ curl -LsSf http://github.com/mxcl/homebrew/tarball/master | sudo tar xvz -C/usr/local --strip 1

</code></pre>

<pre><code class="language-shell">$ sudo brew install wget

$ sudo brew install tomcat

$ sudo brew install unrar

</code></pre>

<h2 id="toc_2">安装cmake</h2>

<ul>

<li>在官网下载cmake.tar.gz并解压</li>

<li>进入解压的文件夹</li>

</ul>

<pre><code class="language-shell">$ tar xvf cmake-xxx.tar.gz

$ cd cmake-xxx

$ ./bootstrap

$ make

$ make all

</code></pre>

<h3 id="toc_3">安装maven</h3>

<ul>

<li>在官网下载maven-xxx.tar.gz并解压</li>

</ul>

<pre><code class="language-shell"># 若/usr/local/maven文件夹不存在，则新建一个

$ mv maven-xxx.tar.gz /usr/local/maven

$ sudo vim /etc/bashrc

# 在bashrc文件尾部新增如下：

M3_HOME=/usr/local/maven

PATH=$M3_HOME/bin:$PATH

export M3_HOME PATH

#结束后保存

$ source bashrc

# 测试maven是否安装完毕

$ mvn -version

</code></pre>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767161005061.html</id>

<content type="html"><![CDATA[

<h2 id="toc_0">依赖倒置指导方针</h2>

<ul>

<li>变量不可以持有具体类的引用</li>

<li>不要让类派送自具体类</li>

<li>不要覆盖基类中已实现的方法</li>

</ul>

<ul>

<li>找出应用在可能需要变化之处，把他们独立出来，不要和那些不需要变化的代码混在一起</li>

<li>针对接口编程，而不是针对实现编程</li>

<li>为了交互对象之间的松耦合设计而努力</li>

<li>类应该对扩展开放，对修改关闭</li>

<li>要依赖抽象，不要依赖具体</li>

<li>最少知识原则：只和你的密友谈话</li>

<li>好莱坞原则：别调用(打电话)我们，我们会调用(打电话给)你</li>

<li>单一责任：一个类应该只有一个引起变化的原因</li>

</ul>

<ul>

<li>内聚：用来度量一个类或模块紧密地达到单一目的或责任。当一个模块或者一个类被设计成只支持一组相关的功能时，我们说它具有高内聚；反之，当被设计成支持一组不相关的功能时，我们说他具有低内聚。</li>

</ul>

<p>定义了算法簇，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。</p>

</blockquote>

<ul>

<li>良好的OO设计必须具备可用性，复用性，可维护三个特性</li>

</ul>

<h3 id="toc_5">观察者模式</h3>

<p>定义了对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会受到通知并自动更新。</p>

</blockquote>

<ul>

<li>观察者模式定义了对象之间的一对多关系</li>

<li>主题（也就是可观察者）用一个共同的接口来更新观察者</li>

<li>观察者和可观察者之间用松耦合的方式结合，可观察者不知道观察者的细节，只知道可观察这实现了观察者的接口</li>

<li>使用此模式时，可从被观察者处push或者pull数据（然而，push的方式被认为更正确）</li>

<li>有多个观察者时，不可以依赖特点的通知次序</li>

</ul>

<h3 id="toc_6">装饰者模式</h3>

<p>动态地将责任附加到对象上，若扩展功能，装饰者提供了比继承更有弹性的替代方案。</p>

</blockquote>

<ul>

<li>继承属于拓展形式之一，但不见得是达到弹性设计的最佳方式</li>

<li>在我们的设计中，应该允许行为可以被扩展，而无须修改现有的代码</li>

<li>组合和委托可用于在运动时动态地加上新的行为</li>

<li>除了继承，装饰者模式也可以让我们扩展行为</li>

<li>装饰者模式意味着一群装饰者类，这些类用来包装具体组件</li>

<li>装饰者类反应出被装饰的组件类型（事实上，他们具有相同的类型，都经过接口或继承实现）</li>

<li>装饰者可以在被装饰者的行为前面或后面加上自己的行为整个取代掉，而达到特定的目的</li>

<li>装饰者一般对组件的客户是透明的，除非客户程序依赖于组件的具体类型</li>

<li>装饰者会导致设计中出现许多小对象，如果过度使用，会让程序变得复杂</li>

</ul>

<h3 id="toc_7">工厂方法模式</h3>

<p>定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。</p>

</blockquote>

<h3 id="toc_8">抽象工厂模式</h3>

<p>提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。</p>

</blockquote>

<ul>

<li>所有的工厂都是用来封装对象的创建</li>

<li>简单工厂，虽然不是真正的设计模式，但仍不失为一个简单的方法，可以将客户程序从具体类解耦</li>

<li>工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象</li>

<li>抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中</li>

<li>所有工厂模式都通过减少应用程序和具体类之间的依赖促进松耦合</li>

<li>工厂方法允许类将实例化延迟到子类进行</li>

<li>抽象工厂创建相关的对象家族，而不需要依赖他们的具体类</li>

<li>依赖倒置原则，指导避免依赖具体类型，而要尽量依赖抽象</li>

<li>工厂是很有威力的技巧，帮助针对抽象编程，而不要针对具体类编程<br/></li>

</ul>

<p>确保一个类只有一个实例，并提供一个全局访问点。</p>

</blockquote>

<ul>

<li>单例模式确保程序中一个类最多只有一个实例</li>

<li>单例模式也提供访问这个实例的全局点</li>

<li>在JAVA中实现单例模式需要私有构造器、一个静态方法和一个静态变量</li>

<li>确定在性能和资源上的限制，然后小心地选择适当- 如果使用多个类加载器，可能导致单例失效而产生多个实例</li>

</ul>

<p>将“请求”封装成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。</p>

</blockquote>

<ul>

<li>命令模式将发出请求的对象和执行请求的对象解耦</li>

<li>在被解耦的两者之间是通过命令对象进行沟通的。命令对象封装了接受者和一个或一组动作</li>

<li>调用者通过调用命令对象的execute()发出请求，这会使得接收者的动作被调用</li>

<li>调用者可以接受命令当做参数，甚至在运行时动态地进行</li>

<li>命令可以支持撤销，做法是实现一个undo()方法来回到execute()被执行前的状态</li>

<li>宏命令是命令的一种简单的延伸，允许调用多个命令。宏方法也可以支持撤销</li>

</ul>

<h3 id="toc_11">适配器模式</h3>

<pre><code>将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

</code></pre>

<h3 id="toc_12">定义外观模式</h3>

<p>提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。</p>

</blockquote>

<ul>

<li>当需要使用一个现有的类而其接口并不符合你的需要时，就使用适配器</li>

<li>当需要简化并同意一个很大的接口或者一群复杂的接口时，使用外观</li>

<li>适配器改变接口以符合客户的期望</li>

<li>外观将客户从一个复杂的子系统中解耦</li>

<li>实现一个适配器可能需要一番功夫，也可能不费功夫，视目标接口的大小和复杂而定</li>

<li>实现一个外观，需要将子系统组合进外观中，然后将工作委托给子系统执行</li>

<li>适配器模式有两种形式：对象适配器和类适配器。类适配器需要用到多重继承</li>

<li>可以为子系统实现一个以上的外观</li>

<li>适配器将一个对象包装起来改变其接口；装饰者将一个对象包装起来以增加新的行为和责任；而外观将一群对象“包装”起来以简化其接口</li>

</ul>

<h3 id="toc_13">模板方法模式</h3>

<p>在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤。</p>

</blockquote>

<ul>

<li>模板方法定义了算法的步骤，把这些步骤的实现延迟到子类</li>

<li>模板方法模式为我们提供了一种代码复用的重要技巧</li>

<li>模板方法的抽象类可以定义具体方法、抽象方法和钩子</li>

<li>抽象方法由子类实现</li>

<li>钩子是一种方法，它在抽象类中不做事，或者只做默认的事，子类可以选择要不要去覆盖它</li>

<li>为了防止子类改变模板方法中的算法，可以将模板方法申明为final</li>

<li>好莱坞原则告诉我们，将决策权放在高层模块中，以便决定如何以及何时调用底层模块</li>

<li>策略模式和模板模式都封装算法，一个用组合，一个用继承</li>

<li>工厂方法是模板方法的一个特殊版本</li>

</ul>

<h3 id="toc_14">迭代器模式</h3>

<p>提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。</p>

</blockquote>

<ul>

<li>迭代器允许访问聚合的元素，而不需要暴露它的内部结构</li>

<li>迭代器将遍历聚合的工作封装进一个对象中</li>

<li>当使用迭代器的时候，我们依赖聚合提供遍历</li>

<li>迭代器提供了一个通用的接口，让我们遍历聚合的项，当我们编码使用聚合的项时，就可以使用多态机制</li>

</ul>

<p>允许你将对象组合组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。</p>

</blockquote>

<ul>

<li>组合模式提供一个结构，可以同时包容个别对象以及组合对象</li>

<li>组合模式允许客户对个别对象以及组合对象一视同仁</li>

<li>组合结构内的任意对象称为组件，组件可以是组合，也可以是叶节点</li>

<li>在实现组合模式时，有许多设计上的折衷。要根据需要平衡透明性和安全性</li>

</ul>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767158161823.html</id>

<content type="html"><![CDATA[

<h2 id="toc_0">FIFO[先入先出队列]</h2>

<p>First Input First Output的缩写，先入先出队列，这是一种传统的按序执行方法，先进入的指令先完成并引退，跟着才执行第二条指令。</p>

<p>基于角色的访问控制（Role-Based Access Control）作为传统访问控制（自主访问，强制访问）的有前景的代替受到广泛的关注。在RBAC中，权限与角色相关联，用户通过成为适当角色的成员而得到这些角色的权限。这就极大地简化了权限的管理。在一个组织中，角色是为了完成各种工作而创造，用户则依据它的责任和资格来被指派相应的角色，用户可以很容易地从一个角色被指派到另一个角色。角色可依新的需求和系统的合并而赋予新的权限，而权限也可根据需要而从某角色中回收。角色与角色的关系可以建立起来以囊括更广泛的客观情况。</p>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767156965797.html</id>

<content type="html"><![CDATA[

<h2 id="toc_0">添加SlidingMenu到自己的项目上：</h2>

<pre><code>由于这是一个开源的项目，没有jar包，所以在这里给出添加方法［在android studio上］

</code></pre>

<ol>

<li>下载slidingMenu源代码， <a href="https://github.com/jfeinstein10/SlidingMenu">戳我，我是地址君</a></li>

<li>新建一个Android项目</li>

<li>单击Project structure --> 单击“＋” --> 选择Phone and Table Application 并在下面的more modules里选择 Import exist project</li>

<li><p>单击next，并选择slidingMenu的下载路径［只需要library部分］，单击finish</p>

<p>到此，准备工作完成。<br/>

⚠ 导入之后出现不能识别的问题，注意项目中的gradle，看看依赖关系中是否有slidingMenu项目。例如：</p></li>

</ol>

<pre><code class="language-gradle"> dependencies{

compile fileTree(dir: 'lib', include: ['*.jar'])

compile (project (":slidingMenu"))

complie 'com.android.support:appcompat-v7:21.0.2'

}

</code></pre>

<h2 id="toc_1">SlidingMenu 的常用属性：</h2>

<pre><code class="language-java">menu.setMode(SlidingMenu.LEFT);

//设置左滑菜单

menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_FULLSCREEN);

//设置滑动的屏幕范围，该设置为全屏区域都可以滑动

menu.setShadowDrawable(R.drawable.shadow);

//设置阴影图片

menu.setShadowWidthRes(R.dimen.shadow_width);

//设置阴影图片的宽度

menu.setBehindOffsetRes(R.dimen.slidingmenu_offset);

//SlidingMenu划出时主页面显示的剩余宽度

menu.setBehindWidth(400);

//设置SlidingMenu菜单的宽度

menu.setFadeDegree(0.35f);

//SlidingMenu滑动时的渐变程度

menu.attachToActivity(this, SlidingMenu.SLIDING_CONTENT);

//使SlidingMenu附加在Activity上

menu.setMenu(R.layout.menu_layout);

//设置menu的布局文件

menu.toggle();

//动态判断自动关闭或开启SlidingMenu

menu.showMenu();

//显示SlidingMenu

menu.showContent();

//显示内容

menu.setOnOpenListener(onOpenListener);

//监听slidingmenu打开,关于关闭menu有两个监听，简单的来说，对于menu close事件，一个是when,一个是after

menu.OnClosedListener(OnClosedListener);

//监听slidingmenu关闭时事件

menu.OnClosedListener(OnClosedListener);

//监听slidingmenu关闭后事件

</code></pre>

<pre><code>⚠ 左右都可以划出SlidingMenu菜单只需要设置下面的属性，然后设置右侧菜单的布局文件

menu.setMode(SlidingMenu.LEFT_RIGHT);

menu.setSecondaryShadowDrawable(R.drawable.shadowright);

//右侧菜单的阴影图片

</code></pre>

<p>布局：这里我偷个懒，三个界面使用同一个layout［activity_test.xml］</p>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

android:orientation="vertical"

android:layout_width="match_parent"

android:layout_height="match_parent">

<TextView

android:layout_width="match_parent"

android:layout_height="match_parent"

android:text="Hello, World"

android:gravity="center"

android:textSize="40sp"/>

</LinearLayout>

</code></pre>

<p>阴影：这里我做了左右侧滑，所以需要两个shadow文件［shadow.xml, shadow_2.xml］</p>

<gradient

android:endColor="#33000000"

android:centerColor="#11000000"

android:startColor="#00000000" />

</shape>

</code></pre>

<gradient

android:endColor="#00508074"

android:centerColor="#113583ff"

android:startColor="#333583ff" />

</shape>

</code></pre>

<pre><code>⚠ 在values/dimens.xml中写一下需要用到的属性

</code></pre>

</resources>

</code></pre>

<p>Activity的实现</p>

<pre><code class="language-java">import android.app.Activity;

import android.os.Bundle;

import android.view.Menu;

import com.slidingmenu.lib.SlidingMenu;

import com.violorch.menudemo.R;

/**

* Created by violorch on 14-11-27.

public class TestActivity extends Activity {

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_test);

/*** 初始化侧滑菜单 Begin ***/

SlidingMenu menu = new SlidingMenu( this);

//这里模式设置为左右都有菜单，RIGHT显示右菜单，LEFT显示左菜单，LEFT_RIGH显示左右菜单

menu.setMode(SlidingMenu.LEFT_RIGHT);

menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_FULLSCREEN );

//设置阴影

menu.setShadowWidthRes(R.dimen.shadow_width);

menu.setBehindOffsetRes(R.dimen.slidingmenu_offset );

menu.setFadeDegree(0.35f);

menu.attachToActivity( this, SlidingMenu.SLIDING_CONTENT );

// left

menu.setMenu(R.layout.activity_ceshi);

menu.setShadowDrawable(R.drawable.shadow);

// right

menu.setSecondaryMenu(R.layout.activity_test);

menu.setSecondaryShadowDrawable(R.drawable.shadow_2);

/*** 初始化侧滑菜单 End ***/

}

@Override

public boolean onCreateOptionsMenu(Menu menu) {

// Inflate the menu; this adds items to the action bar if it is present.

getMenuInflater().inflate(R.menu.menu_main, menu);

return true;

}

</code></pre>

<p>⚠ 到此， slidingMenu的初步实现已经完成。</p>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767153911909.html</id>

<content type="html"><![CDATA[

<a href="http://blog.csdn.net/singwhatiwanna/article/details/17041691">http://blog.csdn.net/singwhatiwanna/article/details/17041691</a></p>

<h2 id="toc_0">AIDL的作用</h2>

<p>AIDL(Android Interface Definition Language) 是一种IDL语言，用于生成可以在Android两个进程之间进行进程间通信(interprocess communication, IPC)的代码。如果在一个进程中(例如Activity)要调用另一个进程中(例如Service)对象的操作，就可以使用AIDL生成可序列化的参数。</p>

<hr/>

<h2 id="toc_1">AIDL的使用场合</h2>

<p>只有当允许客户端从不同的应用程序为了进程间通信而去访问你的service，以及想在你的service处理多线程。无论如何，在使用AIDL之前，必须理解如何绑定service——bindService。</p>

<hr/>

<h2 id="toc_2">如何使用AIDL</h2>

<p><strong>To be continus...</strong></p>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767152130925.html</id>

<content type="html"><![CDATA[

<h2 id="toc_0">在启动Android Studio时，弹出“Fetching Android SDK component information”。并且一直没有进入程序</h2>

<ul>

<li>打开Android Studio的安装目录下的bin目录</li>

<li>在bin目录下，找到idea.properties文件</li>

<li>打开idea.properties文件</li>

<li>在最后一行添加 <code>disable.android.first.run=true</code></li>

</ul>

<hr/>

<h2 id="toc_1">Unable to execute DX</h2>

<p>整个project包含好几个module，其中有一个jar包同时存在于两个module的libs下，在项目build的时候，两个相同的jar都被打包到dex文件中，编译器搞不定，就出了这么个错误了。解决的办法也比较简单：删除重复的jar，只保留一个！</p>

<hr/>

<h2 id="toc_2">No resource identifier found for attribute 'showAsAction' in package 'android'</h2>

<p>showAsAction was added in API level 11要将API提升到11，添加 "android-support-v7-appcompat.jar" 到Android库（ Private Libraries）<br/>

android:showAsAction = "never"<br/>

当你的应用程序目标设为蜂巢平台时，你可以利用Action Bar部件提供的全部功能，将你的选项菜单项放在Action Bar的右上角，对用户来说使用更方便，控制该行为的主菜单项属性是android:showAsAction。<br/>

　　这个属性可接受的值有：<br/>

　　1、always：这个值会使菜单项一直显示在Action Bar上。<br/>

　　2、ifRoom：如果有足够的空间，这个值会使菜单项显示在Action Bar上。<br/>

　　3、never：这个值使菜单项永远都不出现在Action Bar上。<br/>

　　4、withText：这个值使菜单项和它的图标，菜单文本一起显示。<br/>

不过这里没有用到这高版本，此处删除这个属性就OK了。</p>

<hr/>

<h2 id="toc_3">找不到 android.support.v4.app.TaskStackBuilder$SupportParentable 的类文件</h2>

<p>把 <code>android-support-v4.jar</code> 替换成<code>..\sdk\extras\android\support\v7\appcompat\libs下的android-support-v4.jar</code>。</p>

<hr/>

<h2 id="toc_4">Failure [INSTALL_FAILED_OLDER_SDK]</h2>

<p><code>build.grade</code> 下的 <code>minSdkVersion</code> 、<code>targetSdkVersion</code> 需要与虚拟设备保持一致。</p>

<hr/>

<h2 id="toc_5">intellij中出现19不支持错误</h2>

<p>部分png文件在编译gradle时，会出现该错误。将文件改成jpg格式即可。</p>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767150467979.html</id>

<content type="html"><![CDATA[

<h2 id="toc_0">org.hibernate.HibernateException: Could not obtain transaction-synchronized Session for current thread</h2>

<p>在配置spring mvc时，如果报上面的错，那么在web.xml文件中加上下面的配置</p>

<filter-name>SpringOpenSessionInViewFilter</filter-name>

<filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>SpringOpenSessionInViewFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

</code></pre>

<hr/>

<h2 id="toc_1">javax.servlet.ServletException: Could not resolve view with name</h2>

<p>拦截了一个不能转换为servlet的文件。</p>

<hr/>

<h2 id="toc_2">spring 4.0.2 换成 spring 4.1.6， @ResponseBody时，出现如下错误</h2>

<pre><code>java.lang.IllegalStateException: getOutputStream() has already been called for this response

</code></pre>

<groupId>com.fasterxml.jackson.core</groupId>

<artifactId>jackson-databind</artifactId>

</dependency>

</code></pre>

<p>将上面的jar换成下面的</p>

]]></content>

</entry>

<entry>

<id>https://lorch.github.io/14767146711676.html</id>

<content type="html"><![CDATA[

<p>转自 <a href="http://www.cnblogs.com/fickleness/archive/2013/06/21/3149011.html">Java向上转型和向下转型</a></p>

<p>转型是在继承的基础上而言的，继承是面向对象语言中，代码复用的一种机制。通过继承，子类可以复用父类的功能。如果父类不恩能够满足当前子类的需求，则子类可以重写弗雷中的方法来加以扩展。</p>

<p><strong>向下转型：</strong>子类引用的对象转换为父类类型。通俗地说就是将子类对象转为父类对象。此处父类对象可以是借口</p>

<p><strong>向下转型：</strong>父类引用的对象转换为子类类型。</p>

<p>前者是一个向上转型。Animal dog引指向new Dog(); 子类对象当成父类对象，只能调用父类的成员，如果子类重写了父类的方法，就根据这个引用指向调用子类重写的这个方法（这个方法就是覆盖Override）。这个调用过程就称为“动态绑定”。</p>

<p><strong>转型需要注意的问题：</strong>：<br/>

向上转型时，父类指向子类引用对象会遗失父类对象没有的其他方法，在编译时，系统会提示找不到方法的错误。</p>

<p><strong>在向下转型过程中，分为两种情况</strong>：</p>

<ul>

<li>情况一：如果父类引用的对象如果引用的是指向的子类对象，那么在向下转型的过程中是安全的。也就是编译是不会出错误的。</li>

<li>情况二：如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误。</li>

</ul>

<pre><code class="language-java">public class Father {

public void smile(){

System.out.println("Father smile()...");

}

class Child extends Father{

@Override

public void smile() {

System.out.println("Child smile sounds sweet...");

}

public void c(){

System.out.println("Child c()...");

}

class main{

public static void main(String[] args) {

Father g1 = new Child(); //向上转型

g1.smile(); //Child smile sounds sweet...

Child mmg = (Child)g1; //向下转型,编译和运行皆不会出错

mmg.smile(); //Child smile sounds sweet...

mmg.c(); //Child c()...

Father g2 = new Father();

//Child mmg1 = (Child)g2; //不安全的向下转型,编译无错但会运行会出错

//mmg1.smile();

//mmg1.c();

if(g2 instanceof Child){

Child mmg1 = (Child)g2;

mmg1.smile();

mmg1.c();

}

</code></pre>

<ul>

<li>父类引用可以指向子类对象，子类引用不能指向父类对象。</li>

<li>把子类对象直接赋给父类引用叫upcasting向上转型，向上转型不用强制转型。

如Father father = new Child();</li>

<li>把指向子类对象的父类引用赋给子类引用叫向下转型（downcasting），要强制转型。如father就是一个指向子类对象的父类引用，把father赋给子类引用son 即Child child =（Child）father；其中father前面的（Son）必须添加，进行强制转换。</li>

<li>upcasting 会丢失子类特有的方法,但是子类overriding 父类的方法，子类方法有效</li>

<li>向上转型的作用，减少重复代码，父类为参数，调有时用子类作为参数，就是利用了向上转型。这样使代码变得简洁。体现了JAVA的抽象编程思想。</li>

</ul>

View remainder of file in raw view

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

atom.xml

Latest commit

History

atom.xml

File metadata and controls