从0开始学Swift笔记整理（四）

这是跟在上一篇博文后续内容：

——重写方法

重写实例方法

在子类中重写从父类继承来的实例方法和静态方法。先介绍实例方法的重写。

下面看一个示例：

class Person {

var name: String

var age: Int

func description() -> String { //实例方法

return "\(name) 年龄是: \(age)"

}

class func printClass() ->() { //静态方法

print( "Person 打印...")

}

init (name: String, age: Int) {

self.name = name

self.age  = age

}

}

class Student: Person {

var school: String

convenience init() {

self.init(name: "Tony",
age: 18, school: "清华大学")

}

init (name: String, age: Int, school: String) {

self.school = school

super.init(name: name, age: age)

}

override func description() -> String { //重写实例方法description，重写的方法前面要添加关键字override

print("父类打印
\(super.description())")

return "\(name) 年龄是: \(age), 所在学校: \(school)。"

}

override class func printClass() ->() { //重写静态方法printClass

print( "Student 打印...")

}

}

let student1 = student()

print("学生1：\(student1.description())") //调用了description方法

Person.printClass()

Student.printClass()

使用super.description()语句调用父类的description方法，其中super指代父类实例。

重写静态方法printClass，在静态方法中不能访问实例属性。

调用了description方法。由于在子类中重写了该方法，所以调用的是子类中的description方法。输出结果是：

父类打印 Tony 年龄是: 18

学生1：Tony 年龄是: 18, 所在学校: 清华大学。

为了测试静态方法重写，调用Person.printClass()语言，它是调用父类的printClass静态方法，输出结果是：

Person 打印...

调用Student.printClass()语言，它是调用子类的printClass静态方法，输出结果是：

Student 打印...

重写静态方法

与类的静态属性定义类似，静态方法使用class或static关键字，但是使用哪一个要看子类中是否重写该方法。class修饰的静态方法可以被重写，static关键字就不能被重写。

示例代码如下：

class Account {

var owner: String = "Tony"    
//账户名

//不能换成static

class func interestBy(amount: Double) -> Double
{   //静态方法

return 0.08886 * amount

}

}

class TermAccount: Account {//定期账户

//可以换成static

override class func interestBy(amount: Double) -> Double
{ //静态方法

return 0.09 * amount

}

}

//调用静态方法

print(Account.interestBy(10_000.00 ))

print(TermAccount.interestBy(10_000.00 ))

由于被重写所以代码class func interestBy(amount: Double) ->
Double中的class不能换成static。静态方法interestBy可以使用class或static，除非在TermAccount的子类中重写方法interestBy。

——下标重写

下标是一种特殊属性。子类属性重写是重写属性的getter和setter访问器，对下标的重写也是重写下标的getter和setter访问器。

下面看一个示例：

class DoubleDimensionalArray {

let rows: Int, columns: Int

var grid: [Int]

init(rows: Int, columns: Int) {

self.rows = rows

self.columns = columns

grid = Array(count: rows * columns,
repeatedValue: 0)

}   

    subscript(row:
Int, col: Int) -> Int { //定义下标

get {

return
grid[(row * columns) + col]

}

set {

grid[(row *
columns) + col] = newValue

}

}        //定义下标

}

class SquareMatrix: DoubleDimensionalArray {

override subscript(row: Int, col: Int) -> Int { //重写父类下标

get {

return
super.grid[(row * columns) + col]

}

set {

super.grid[(row * columns) + col] = newValue * newValue

}

}

}

var ary2 = SquareMatrix(rows: 5, columns: 5)

for var i = 0; i < 5; i++ {

for var j = 0; j < 5; j++ {

ary2[i,j] = i + j

}

}

for var i = 0; i < 5; i++ {

for var j = 0; j < 5; j++ {

print("\t\t \(ary2[i,j])")

}

print("\n")

}

其中super.grid[(row * columns) + col]语句中使用super调用父类的grid属性。

其中super.grid[(row * columns) + col] = newValue *
newValue语句是给父类的grid属性赋值。

——final关键字

在类的定义中使用final关键字声明类、属性、方法和下标。final声明的类不能被继承，final声明的属性、方法和下标不能被重写。

下面看一个示例：

final class Person { //声明为final，说明它是不能被继承的

var name: String

final var age: Int //定义的age属性

final func description() -> String { //定义description实例方法

return "\(name) 年龄是: \(age)"

}

final class func printClass() ->() { //定义printClass静态方法

print( "Person 打印...")

}

init (name: String, age: Int) {

self.name = name

self.age  = age

}

}

class Student: Person
{                           
//编译错误

var school: String

convenience init() {

self.init(name: "Tony",
age: 18, school: "清华大学")

}

init (name: String, age: Int, school: String) {

self.school = school

super.init(name: name, age: age)

}

override func description() -> String
{         //编译错误 //试图重写description实例方法

print("父类打印 \(super.description())")

return "\(name) 年龄是: \(age), 所在学校: \(school)。"

}

override class func printClass() ->()
{      //编译错误 //试图重写printClass静态方法

print( "Student 打印...")

}

override var age: Int
{                       
//编译错误 //试图重写age属性

get {

return super.age

}

set {

super.age = newValue < 8 ? 8:
newValue

}

}

}

定义Student类，并声明为Person子类时，会报如下编译错误：

Inheritance from a final class ‘Person‘

定义的age属性也是final，那么在试图重写age属性时，会报如下编译错误：

Var overrides a ‘final‘ var

定义description实例方法，它被声明为final，那么在试图重写description实例方法时，会报如下编译错误：

Instance method overrides a ‘final‘ instance method

定义printClass静态方法，它被声明为final，那么在试图重写printClass静态方法时，会报如下编译错误：

Class method overrides a ‘final‘ class method

使用final可以控制我们的类被有限地继承，特别是在开发一些商业软件时，适当地添加final限制是非常有必要的。

类型检查与转换

Swift类的类型检查与转换，包括is操作符、as操作符

is操作符可以判断一个实例是否是某个类的类型。如果实例是目标类型，结果返回true，否则为false。

as?操作符是在不确定是否类型转换能够成功情况下使用，如果成功转换结果是可选类型。如果我们能够确保转换一定成功，可以使用as!操作符在转换的同时进行隐式拆包。

——扩展声明

声明扩展的语法格式如下：

extension 类型名 {

//添加新功能

}

声明扩展的关键字是extension，“类型名”是Swift中已有的类型，包括类、结构体和枚举，但是我们仍然可以扩展整型、浮点型、布尔型、字符串等基本数据类型，这是因为这些类型本质上也是结构体类型。打开Int的定义如下：

struct Int : SignedInteger {

init()

init(_ value: Int)

static func convertFromIntegerLiteral(value: Int) -> Int

typealias ArrayBoundType = Int

func getArrayBoundValue() -> Int

static var max: Int { get }

static var min: Int { get }

}

从定义可见Int是结构体类型。不仅是Int类型，我们熟悉的整型、浮点型、布尔型、字符串等数据类型本质上都是结构体类型。

Swift中的扩展机制可以在原始类型中添加的新功能包括：

· 实例计算属性和类型计算属性

· 实例方法和类型方法

· 构造函数

· 下标

还有嵌套类型等内容也可以扩展，扩展还可以遵从协议。

——扩展计算属性、方法

可以在原始类型上扩展计算属性，包括实例计算属性和静态计算属性。添加计算属性的定义，与普通的计算属性的定义是一样的。

实例计算属性示例：在网络编程时，为了减少流量，从服务器端返回的不是信息描述，而是编码，然后在本地再将编码转换为描述信息。为此定义了如下Int类型扩展：

extension Int {    //定义Int类型的扩展

var errorMessage : String { //只读计算属性

var errorStr = ""

switch (self) {

case -7:

errorStr =
"没有数据。"

case -6:

errorStr =
"日期没有输入。"

case -5:

errorStr =
"内容没有输入。"

case -4:

errorStr =
"ID没有输入。"

case -3:

errorStr =
"据访问失败。"

case -2:

errorStr =
"您的账号最多能插入10条数据。"

case -1:

errorStr =
"用户不存在，请到http://51work6.com注册。"

default:

errorStr =
""

}

return errorStr

}

}

let message = (-7).errorMessage  //获得-7编码对应的描述信息

print("Error Code : -7 , Error Message : \(message)")

注意整个-7包括负号是一个完整的实例，因此调用它的属性时需要将-7作为一个整体用小括号括起来。然而，如果是7则不需要括号。

下面再看一个静态属性的示例：

struct Account {    //定义Account结构体

var amount : Double = 0.0              
//账户金额

var owner : String =
""                
//账户名

}

extension Account {   //定义Account结构体的扩展静态

static var interestRate : Double
{      //利率

return 0.0668

}

}

print(Account.interestRate) //打印输出interestRate属性

打印输出interestRate属性，访问方式与其他的静态计算属性一样，通过“类型名”加“.”来访问静态计算属性。

扩展方法

可以在原始类型上扩展方法，包括实例方法和静态方法。这些添加方法的定义与普通方法的定义是一样的。

——Cocoa错误处理模式

Swift错误处理模式，在Swift 1.x和Swift 2.0是不同的两种模式。

Swift 1.x代码错误处理模式采用Cocoa框架错误处理模式，到现在Objective-C还沿用这种处理模式，而Swift 2.0之后采用了do-try-catch错误处理模式。

下面的示例代码是从文件中读取字符串到内存中，如果使用Swift 1.x错误处理模式代码如下：

import Foundation

var err: NSError?        //定义可选的NSError?变量
let contents = NSString(contentsOfFile: filePath, encoding: 
NSUTF8StringEncoding, error: &err)
if err != nil {        //判断err变量是否还是nil
// 错误处理
}

NSError?一定是可选的变量，因为要给它初始化为nil。

判断err变量是否还是nil，如果还是nil在代码

let contents = NSString(contentsOfFile: filePath,
encoding: NSUTF8StringEncoding, error: &err)

方法调用过程中没有发生错误，否则说明有错误发生。

上述代码的构造函数，它的Swift语法定义如下：

init?(contentsOfURL url: NSURL,
     encoding enc: UInt,
error error: NSErrorPointer)

构造函数的最后一个参数是NSErrorPointer（即NSError指针），那么在实际调用时候我们需要传递err变量地址（即&err），&是取地址符。当方法调用完成后，如果有错误则err变量会被赋值。

——do-try-catch错误处理模式

Swift 1.x的错误处理模式存在很多弊端，例如：为了在编程时候省事，给error参数传递一个nil，或者方法调用完成后不去判断error是否为nil，不进行错误处理。

let contents = NSString(contentsOfFile: filePath, 
encoding: NSUTF8StringEncoding, error: nil)//error参数传递一个nil

或者

var err: NSError?    
let contents = NSString(contentsOfFile: filePath, encoding:
              NSUTF8StringEncoding, error: &err)

不好的编程习惯，由于Objective-C和Swift 1.x没有强制处理机制，因此一旦真的发生错误，程序就会发生崩溃。

同样的从文件中读取字符串示例，如果使用Swift 2错误处理模式代码如下：

import Foundation
do {    //要做一些操作
let str = try NSString(contentsOfFile: filePath, encoding: 
         NSUTF8StringEncoding)    //要尝试做的事情
} catch let err as NSError {    //如果失败则进入catch代码块
      err.description
}
do-try-catch这种错误模式与Java中异常处理机制非常类似，本意就是尝试（try）做一件事情，如果失败则捕获（catch）处理。

捕获错误。完整的do-try-catch错误处理模式的语法如下：

do {
try 语句
成功处理语句组 
} catch 匹配错误 {
   错误处理语句组
}

在try 语句中可以产生错误，当然也可能不会产生错误，如果有错误发生，catch就会处理错误。catch代码块可以有多个，错误由哪个catch代码块处理是由catch后面的错误匹配与否而定的。错误类型的多少就决定了catch可以有多少。

错误类型：在Swift中错误类型必须遵从ErrorType 协议，其次考虑到错误类型的匹配，它应该被设计成为枚举类型，枚举类型非常适合将一组相关值关联起来。

如果我们编写访问数据库表程序，实现对表数据插入、删除、修改和查询等操作，我们会需要类似如下代码的错误类型：

enum DAOError: ErrorType {
case NoData
case PrimaryKeyNull
}

NoData表示没有数据情况，PrimaryKeyNull表示表的主键（Primary Key）为空情况。那么我们就可以通过如下代码捕获错误。

do {    
//try 访问数据表函数或方法
} catch DAOError.NoData {
    print("没有数据。")
} catch DAOError.PrimaryKeyNull {
    print("主键为空。")
}

——抛出错误

能放到try后面调用函数或方法都是有要求的，他们是有可能抛出错误，在这些函数或方法声明的参数后面要加上throws关键字，表示这个函数或方法可以抛出错误。

声明抛出错误方法示例代码如下：

//删除Note记录方法
func remove(model: Note) throws {
    ...
}
//查询所有记录数据方法
func findAll() throws -> [Note] {
    ...
}

上述代码remove(_:)方法没有返回值，throws关键字放到参数后面。findAll()有返回值throws关键字放到参数和返回值类型之间。

在函数或方法中抛出错误

一个函数或方法能够声明抛出错误，是因为在函数或方法中产生并抛出了错误，这样函数或方法声明抛出错误才有实际的意义。

在产生并抛出错误方式：

· 在函数或方法中通过throw语句，人为地抛出错误。

· 在函数或方法中调用的其他可以抛出错误函数或方法，但是没有捕获处理，    会导致错误被传播出来。

guard语句最擅长处理这种早期判断，条件为false情况下抛出错误。

findAll()语句本身有可能产生错误，但是并没有使用catch语句捕获并处理，这样就导致了这个错误传播给该函数或方法的调用者，如果它的调用者也都不捕获处理，那么最后程序会出现运行期错误。

——使用try?和try!区别

1.使用try?

try?会将错误转换为可选值，当调用try?＋函数或方法语句时候，如果函数或方法抛出错误，程序不会发崩溃，而返回一个nil，如果没有抛出错误则返回可选值。

示例代码如下：

//查询所有数据方法
func findAll() throws -> [Note] {
    guard listData.count > 0 else {
    //抛出"没有数据"错误。
    throw DAOError.NoData
    }
    return listData
}
let datas  = try? findAll()    
print(datas)

上述代码中let datas = try? findAll()语句中使用了try?，datas是一个可选值，本例中输出nil。使用了try?语句没有必要使用do-catch语句将其包裹起来。

2.使用try!

使用try!可以打破错误传播链条。错误抛出后传播给它的调用者，这样就形成了一个传播链条，但有的时候确实不想让错误传播下去，可以使用try!语句。

修改上述代码如下：

//查询所有数据方法
func findAll() throws -> [Note] {
    guard listData.count > 0 else {
    //抛出"没有数据"错误。
    throw DAOError.NoData
    }
    return listData
}
func printNotes() {
let datas  = try! findAll()        
for note in datas {
      print("date : \(note.date!) - content: \(note.content!)")
   }
}
printNotes()

代码printNotes()函数没有声明抛出错误，在调用它的时候不需要try关键字，错误传播链条在printNotes()函数内被打破了。

代码将try dao.findAll()语句改为try!
findAll()，在try后面加了感叹号（!），这样编译器就不会要求printNotes()方法声明抛出错误了，try!打破了错误传播链条,但是如果真的发生错误就出现运行期错误，导致程序的崩溃。

所以使用try!打破错误传播链条时，应该确保程序不会发生错误。

——Swift编码规范之命名规范

· 匈牙利命名，一般只是命名变量，原则是：变量名=类型前缀+描述，如bFoo表示布尔类型变量，pFoo表示指针类型变量。匈牙利命名还是有一定争议的，在Swift编码规范中基本不采用匈牙利命名。

· 驼峰命名（Camel-Case），又称骆驼命名法，是指混合使用大小写字母来名字。驼峰命名又分为：小驼峰法和大驼峰法。

a) 小驼峰法是第一个单词是全部小写，后面的单词首字母大写，如：myRoomCount；

b) 大驼峰法是第一个单词的首字母也大写，如：ClassRoom。

驼峰命名是Swift编码规范主要的命名方法，更加所命名的内容不同，可以选择小驼峰法还是大驼峰法。下面分类说明一下：

1. 对类、结构体、枚举和协议等类型命名，应该采用大驼峰法，如SplitViewController。

2. 文件名，采用大驼峰法，如BlockOperation.swift。

3. 扩展文件，有的时候扩展是定义在一个独立的文件中的，它的命名是“原始类型名+扩展名”作为扩展文件名，如NSOperation+Operations.swift。

4. 变量和属性，采用应该采用小驼峰法，如studentNumber。

5. 常量，采用大驼峰法，如MaxStudentNumber。

6. 枚举成员，与常量类似，采用大驼峰法，如ExecutionFailed。

7. 函数和方法，采用应该采用小驼峰法，如balanceAccount、isButtonPressed等。

——Swift编码规范之注释规范：文件注释、文档注释、代码注释、使用地标注释

Swift注释的语法有两种：单行注释（//）和多行注释（/.../）

1、文件注释

文件注释就在每一个文件开头添加注释，文件注释通常包括如下信息：版权信息、文件名、所在模块、作者信息、历史版本信息、文件内容和作用等。

/*
Copyright (C) 2016 Eorient Inc. All Rights Reserved.
See LICENSE.txt for this sample’s licensing information
Description:
This file contains the foundational subclass of NSOperation.
History:
16/10/24: Created by ZRJ.
16/11/12: Add socket library
16/11/14: Add math library
*/

这个注释只是提供了版权信息、文件内容和历史版本信息等，文件注释要根据自己实际情况包括内容。

2、文档注释

文档注释就是这种注释内容能够生成API帮助文档。文档注释主要对类型、属性、方法或函数等功能。 文档注释是稍微将单行注释（//）和多行注释（/.../）做一点“手脚”后，就成为了文档注释，单行文档注释（///）和多行文档注释（/*.../）。

import Foundation
/**
    The protocol that types may implement if they wish to be
             notified of significant operation lifecycle events.
*/
protocol OperationObserver {        
     /// Invoked immediately prior to the `Operation`‘s `execute()` method.
     func operationDidStart(operation: Operation)      
}

3、代码注释

程序代码中处理文档注释还需要在一些关键的地方添加代码注释，文档注释一般是给一些看不到源代码的人看的帮助文档，而代码注释是给阅读源代码人参考的。代码注释一般是采用单行注释（//）和多行注释（/.../）。

有的时候也会在代码的尾端进行注释，这要求注释内容极短，应该在有足够的空白来分开代码和注释。尾端注释示例代码如下：。

init(timeout: NSTimeInterval) {
　　self.timeout = timeout  //初始化
}

4、使用地标注释

随着编码过程深入，工程代码量会增加，任何在这大量的代码中能快速找到需要方法或者是刚才修改过代码呢？

在Swift代码中使用地标注释，然后就可以使用Xcode工具在代码中快速查找了。地标注释有三个：

· MARK，用于方法或函数的注释。

· TODO，表示这里代码有没有完成，还要处理。

· FIXME，表示这里修改了代码。

——代码排版

代码排版包括: 空行、空格、断行和缩进等内容。代码排版内容比较多工作量很多，但是非常重要。

空行：空行将逻辑相关的代码段分隔开，以提高可读性。下列情况应该总是添加空行：

a 类型声明之前。

b import语句前后。

c 两个方法或函数之间。

d 块注释或单行注释之前。

e 方法或函数内的两个逻辑段之间，用以提高可读性。

f 一个源文件的两个片段之间。

空格：在代码中有些位置是需要有空格的，这个工作量也是很大的。下列是使用空格的规范：

1、赋值符号“=”前后有一个空格。var或let与标识符之间有一个空格。所有的二元运算符，应该使用空格将之与操作数分开。一元操作符和操作数之间不因该加空格，如：++、--等。

2、小左括号“(”之后，小右括号“)”之前不要有空格。

3、大左括号“{”之前有一个空格。

4、在方法或函数参数之前间有一个空格，参数冒号与数据类型之间有一个空    格。

断行：一行代码的长度尽量避免超过80个字符，为了便于查看是否一行代码超出80个字符，很多IDE开发工具都可以在编辑窗口设置显示80行竖线。在Xcode中设置过程是打开菜单Xcode→Preferences，选择Text Editing标签，选中Show→Page guide at column。

由于有的代码比较长需要断行，可以依据如下一般规范断开：

1 在一个逗号后面断开。

2 在一个操作符前面断开，要选择较高级别运算符断开，而非较低级别运算符断开。

3 新的一行应该与上一行缩进两个级别（8个空格）

缩进：4个空格常被作为缩进排版的一个单位，在开发时候使用制表符进行缩进，虽然默认情况下一个制表符等于8个空格，但是在不同的IDE工具中可能设置的一个制表符与空格对应个数会有所不同。在Xcode中默认是一个制表符对应4个空格，我们可以在Xcode中打开菜单Xcode→Preferences，选择Text Editing→Indentation标签，可以在Tab width中进行设置。

缩进可以依据如下一般规范：

· 在函数、方法、闭包、控制语句、计算属性等包含大括号“{}”代码块中，代码块中的内容与首行缩进一个级（4个空格）。

· 如果是if语句中条件表达式的断行，那么新的一行应该与上一行缩进两个级别（8个空格），再往后的断行要与第一次的断行对齐。

这是我在学Swift整理的基础笔记，希望给更多刚学IOS开发者带来帮助，在这里博主非常感谢大家的支持！

更多的请到参考我下一篇博文。之后还在持续更新中。。。

时间： 2024-10-10 07:12:42

从0开始学Swift笔记整理（四）的相关文章

从0开始学Swift笔记整理（三）

这是跟在上一篇博文后续内容: --Swift中相关的属性 存储属性 Swift中的属性分为存储属性和计算属性,存储属性就是Objective-C中的数据成员,计算属性不存储数据,但可以通过计算其他属性返回数据.存储属性可以存储数据,分为常量属性(用关键字let定义)和变量属性(用关键var定义). 存储属性概念: 我们在前面曾用到过属性,Employee类和Department结构体.它们的类图如下,Employee 的部门属性dept与Department之间进行了关联. 我们可以在定义存储属

从0开始学Swift笔记整理（一）

Swift 是一种适用于 iOS 和 OS X 应用的全新编程语言,它建立在最好的 C 和 Objective-C 语言之上,并且没有 C 语言的兼容性限制.Swift 采用安全的编程模式,增加了现代功能使 编程更容易.更灵活.更有趣.Swift 以成熟且备受宠爱的 Cocoa 和 Cocoa Touch 框架为 支撑,这是一个重新构想软件开发的机会. --我的第一行Swift代码 import Foundation             //表示引入Foundation框架 var str

从0开始学Swift笔记整理（五）

这是跟在上一篇博文后续内容: --Core Foundation框架 Core Foundation框架是苹果公司提供一套概念来源于Foundation框架,编程接口面向C语言风格的API.虽然在Swift中调用这种C语言风格的API比较麻烦,但是在OS X和iOS开发过程中,有时候使用Core Foundation框架的API是非常方便的,例如在与C语言混合编码的时候. Core Foundation框架与Foundation框架紧密相关,他们具有与相同的接口,但是不同.Core Founda

swift 笔记 (十四) —— 构造过程

构造过程 为了生成类.结构体.枚举等的实例,而做的准备过程,叫做构造过程. 为了这个过程,我们通常会定义一个方法来完成,这个方法叫做构造器.当然它的逆过程,叫做析构器,用于在实例被释放前做一些清理工作以及一此自定义化的处理. 为存储型属性设置初始值 类和结构体在生成实例那一刻,必须为所有的属性赋以特定的初始值. 要么在定义存储型属性的时候直接给个初始值,否则就必须在构造器里面指定一个初始值. 上面说的这两种情况,都不会触发存储型属性的监听者行为(property observer). struc

Python学习笔记整理(四)Python中的字符串..

字符串是一个有序的字符集合,用于存储和表现基于文本的信息. 常见的字符串常量和表达式 T1=‘’ 空字符串 T2="diege's" 双引号 T3="""...""" 三重引号块 T4=r'\temp\diege' Raw字符串 抑制(取消)转义,完全打印\tmp\diege,而没有制表符 T5=u’diege' Unicode字符串 T1+T2     合并 T1*3    重复 T2[i]    索引 T2[i:j] 分片

Python学习笔记整理四--字符串类型

定义:元素以引号包围的.元素可以是任意类型的有序的不可修改的序列: 定义字符串: str()  如:a = str(1234) ''     如:a = 'nihao' ""    如:a = "nihao" ''' ''', """ """ 如:a = '''nihao''', a = """nihao""" 注意: 当需要用到缩写如I'm时,就

老笔记整理四：字符串的完美度

今天在宠果网上发现一道题目,求一个字符串的完美度http://hero.pongo.cn/home/index觉得这道题很有趣就挑战了一下,结果没有在规定的1小时里面写完(笑),多花了10分钟终于做出来了. 题目是这样的:我们要给每个字母配一个1-26之间的整数,具体怎么分配由你决定,但不同字母的完美度不同, 而一个字符串的完美度等于它里面所有字母的完美度之和,且不在乎字母大小写,也就是说字母F和f的完美度是一样的. 现在给定一个字符串,输出它的最大可能的完美度. 例如:dad,你可以将26分配

Struts2学习笔记整理(四)

Struts2上传下载 文件上传 如果想使用HTML表单上传文件(一个或多个),那么必须把HTML表单的enctype属性设置成multipart/form-data,且method=post, 且使用<input type="file">. 在Struts里,我么使用FileUpload拦截器和 Jakarta Commons FileUpload 组件可以完成文件的上传. 步骤:1.在jsp中使用file标签,如果上传一个文件就写一个,多个文件的话使用多个file标签,

Deep Learning（深度学习）学习笔记整理系列之（四）

Deep Learning(深度学习)学习笔记整理系列 [email protected] http://blog.csdn.net/zouxy09 作者:Zouxy version 1.0 2013-04-08 声明: 1)该Deep Learning的学习系列是整理自网上很大牛和机器学习专家所无私奉献的资料的.具体引用的资料请看参考文献.具体的版本声明也参考原文献. 2)本文仅供学术交流,非商用.所以每一部分具体的参考资料并没有详细对应.如果某部分不小心侵犯了大家的利益,还望海涵,并联系博主