4.27

JAVA

封装的应用

public class Student {
        private int size;
        public int geiSize() {
                return size;
        }
        public void setSize(int size) {
                this.size=size;
        }
}

把Student类的成员 size 设置为私有，也就是说只有Student 类的内部成员可直接访问它，但是程序中又为size 成员提供了对外的访问器方法，也就是说其他类只能通过公有访问器访问它。

//与Student类放在同一个包内
public class Student_ {
        //主方法
        public static void main(String args[]) {
                //创建Student类的对象,因为两个类同属一个包,所以可以直接通过类名创建
                Student s1=new Student();
                //调用Student类size成员的公有访问器
                s1.setSize(20);
                //打印
                System.out.println("Student size="+s1.getSize());
        }
}

Student_ 类与 Student 类在同一个包中，在Student_ 类中可以直接创建Student 类的对象，也可以通过调用私有成员size 的公有访问器来访问。

被封装的对象对外发布接口要尽可能的简单化，以便能方便地被其他类或对象所调用

继承

继承使得一个类能够使用另一个类的属性和方法，继承的类也可以通过增加新功能或修改已有功能来创建新类

public class Father {
        public void aa() {
                System.out.println("Father aa!!") ;
        }
        //主方法
        public static void main(String args[]) {
                Father f=new Father();
                //使用父类引用调用父类方法
                f.aa();
                Son s=new Son();
                //使用子类对象调用子类方法
                s.kk();
                //使用子类对象调用从父类继承的公有方法
                s.aa();
        }
}
class Son extends Father {
        public void kk() {
                //直接调用父类中的public方法
                aa();
                //打印
                System.out.println("Son kk!!");
        }
}
       

以上代码是一个简单的继承例子，其中创建了两个类： Father和 Son ，Son类继承自 Father 类。

运行后的结果：

F:\gz\JAVA\fz>java Father
Father aa!!
Father aa!!
Son kk!!
Father aa!!

可以看出，如果子类能够继承父类成员，则它完全和该子类自己实际声明的成员相同，也就是说这个子类拥有这一成员，可以直接使用

私有成员（private）：被标识为private 的成员只能被声明它的类访问，子类不能继承它，

默认和保护成员(protected) ：保护和默认控制级别几乎完全相同，只有在有关子类的时候才是有区别的。

默认访问控制的成员只有在同一个包中才可访问，与是不是子类没有关系

被标识为 protected 的成员无论合适都可被其子类访问，即使不在同一个包中

子类可以直接访问被标识为protected 的成员，就像使用自己声明的成员一样

子类不能在父类引用上使用点运算符来访问父类中的保护成员，只能通过继承看到被保护的成员

Java 语言中类不能多重继承，如果一个类一旦继承了另一个类，那么就不可以再继承其他的类

多态

是对象的一种能力，可以在运行时刻根据传递的对象参数，决定调用哪一个对象的方法。多态是行为的抽象，使得同名方法有不同的响应方式，

Java 语言的多态性的突出优点是，使程序具有良好的扩展性。通过继承，它可以扩展出任意多个新类型，或向父类增加更多的功能方法时，无需修改原有对父类进行处理的相关程序。

public class Test {
        //主方法
        public static void main(String args[]) {
                Person p=new Person(new Car());
                p.driveStop();
                p.v=new Cart();
                p.driveStop();
        }
}
//创建一个抽象父类
abstract class Vecile {
        //抽象方法
        public abstract void stop();
}
//创建Cart类,并扩展Vecile
class Cart extends Vecile {
        //实现Vecile类的抽象方法
        public void stop() {
                System.out.println("Cart stop!!");
        }
}
//创建Car类,并扩展Vecile
class Car extends Vecile {
        //实现Vecile类的抽象方法
        public void stop() {
                System.out.println("Car stop!!");
        }
}
class Person {
        Vecile v;
        //有参构造函数
        public Person(Vecile v) {
                this.v=v;
        }
        public void driveStop() {
                //使用父类引用调用子类方法
                v.stop();
        }
}

上述代码中，Cart 和 Car 类都扩展了Vecile 类，并各自实现了父类的抽象方法。并通过创建父类的引用来调用子类的实现方法

运行结果：

F:\gz\JAVA\fz>java Test
Car stop!!
Cart stop!!

构造函数

基础：与类同名的成员函数是构造函数。它不能有返回值，当创建一个对象时，必须用new 关键字为它分配内存，即调用构造函数，

例如声明一个名称为Constr 的类：

public class Constr {

        void Constr() {

        }

}

上述代码中，Constr 是一个方法，它的名称恰巧与类名相同，但不是构造函数，因为它有返回值。

public class Constr {
        String sname;
        int sage;
        Constr(String sname,int sage) {
                this.sname=sname;
                this.sage=sage;
        }
}

声明了一个名称为Constr 的类并且给出了一个无参构造函数和一个有参构造函数，在主方法中分别通过调用这两个构造函数来创建Constr 类的对象

每个构造函数都会自动调用父类构造函数(super()) 或者重载的构造函数作为构造函数的第一条语句，如果程序员没有显示地输入调用兄弟或父类的构造函数，编译器则会在构造函数的第一行插入 super() 调用无参构造函数，

class A {
      A() {
             System.out.println("类A构造函数执行! ");
        }
}
class B extends A {
      B() {
             System.out.println("类B构造函数执行! ");
        }
}
public class Test {
        public static void main(String args[]) {
                B b=new B();
        }
}

以上程序运行后得到如下结果：

F:\gz\JAVA\gzhs>java Test
类A构造函数执行!
类B构造函数执行!

可以看出，在创建B 类的对象时，首先调用其父类A 的构造函数，然后再执行类B 的构造函数，

在调用类A 的构造函数之前还调用了 Object 类的构造函数，因为JAVA 中所有类都扩展自此类

构造函数的重载

与方法的重载类似，都是名称相同而参数序列不同

public class ConstrTest {
        public ConstrTest() {
                super();
                System.out.println("无参构造函数执行! ");
        }
        public ConstrTest(String s1) {
                super();
                System.out.println("s1="+s1);
        }
        public ConstrTest(String s1,String s2) {
                super();
                System.out.println("s1="+s1+",s2="+s2);
        }
        public static void main(String args[]) {
                //创建对象
                ConstrTest ct1=new ConstrTest();
                ConstrTest ct2=new ConstrTest("AAAA");
                ConstrTest ct3=new ConstrTest("AAAA","BBBB");
        }
}

类ConstrTest 中声明了3个参数不同的构造函数，并在主方法中调用它们来创建对象

运行以上程序：

F:\gz\JAVA\gzhs>java ConstrTest
无参构造函数执行!
s1=AAAA
s1=AAAA,s2=BBBB

重写和重载方法

方法可以重载也可以重写，但是构造函数只能重载

重写可以使子类在需要新的，特有的行为时，重新在子类中定义方法。重写是基于继承的，只有非静态的方法才能被重写。

而对于从父类继承的抽象方法则必须为这些方法提供方法设计，除非这个子类本身也是抽象的类

public class Override {
        public void or() {
                System.out.println("这是父类中的OR方法! ");
        }
}
class Son extends Override {
        public void or() {
                System.out.println("这是子类中的OR方法! ");
        }
}

Son类继承自 Override 类并且声明了一个与 Override 类中返回值和参数序列都同名 or() 方法，构成重写

抽象，继承和多态是面向对象程序设计语言的三大特性，例如：

class MainClass {
        public static void main(String args[]) {
                Override or=new Override();
                Override s=new Son();
                or.or();
                s.or();
        }
}

运行以上的程序得到结果：

F:\gz\JAVA\gzhs>java MainClass
这是父类中的OR方法!
这是子类中的OR方法!

当使用父类的引用指向子类对象时，只允许调用父类中已经定义的方法，否则编译器会报错，

方法的重写

①返回类型必须和被重写的方法完全相同

②参数序列必须和被重写的方法完全相同

③访问级别一定不能比被重写的方法高

public class SuperOverride {
        public void or() {
                System.out.println("这是父类中的OR方法! ");
        }
}
class Son extends SuperOverride {
        public void or() {
                System.out.println("这是子类中的OR方法! ");
                //使用super关键字调用父类的方法
                super.or();
        }
}
class MainClass1 {
        public static void main(String[] args) {
                SuperOverride so=new SuperOverride();
                SuperOverride s=new Son();
                so.or();
                s.or();
        }
}

知道了当使用父类引用指向子类对象时将调用子类的方法。上述的例子就是如何通过使用super 关键字来实现调用父类的方法。

运行结果如下：

F:\gz\JAVA\gzhs>java MainClass1
这是父类中的OR方法!
这是子类中的OR方法!
这是父类中的OR方法!

重载规则

使用重载方法可以处理不同参数类型的功能，调用方法更简单，可以理解为提供了一个功能的多个版本可供选择

①被重载的方法可以改变返回值类型

②被重载的方法必须改变参数序列

③被重载的方法可以改变访问限制修饰符

④被重载的方法可以声明抛出新的异常

⑤方法可以在同一个类中被重载

public class SuperOverload {
        public void or() {
        }
}
class Son extends SuperOverload {
        public void or(String sname) throws NumberFormatException {
        }
}

该代码看似好像违背了重写的规则，但事实上是一个合法的方法重载

不能因为被重新的方法 or() 没有声明抛出异常，而且参数序列也不同，就判定此代码违背了重写规则

实际上，子类的方法并不是重写，因为它的参数已经改变，即构成了重载

方法的重载

public class OverLoad {
        //整数加
        public int add(int x,int y) {
                System.out.println("x="+x+",y="+y);
                return (x+y);
        }
        //小数加
        public double add(double x,double y) {
                System.out.println("x="+x+",y="+y);
                return (x+y);
        }
        public static void main(String args[]) {
                OverLoad ol=new OverLoad();
                //整数加
                System.out.println("x+y="+ol.add(3,2));
                //小数加
                System.out.println("x+y="+ol.add(3.0,2));
        }
}

声明了两个add() 方法，分别用于做整数和双精度数的加法，可以根据实际需要选择调用不同的方法，

编译运行过后得到：

F:\gz\JAVA\gzhs>java OverLoad
x=3,y=2
x+y=5
x=3.0,y=2.0
x+y=5.0

当传入的参数为整数时，会调用做整数加的 add() 方法。除了原始类型的参数外，参数还可以是对象类型：

class Father {}
class Son extends Father {}
public class OverLoad1 {
        //参数为父类类型
        public void did(Father f) {
                System.out.println("Father类型! ");
        }
        //参数为子类类型
        public void did(Son s) {
                System.out.println("Son类型! ");
        }
        //主方法
        public static void main(String atgs[]) {
                OverLoad1 ol=new OverLoad1();
                Father f=new Father();
                Son s=new Son();
                ol.did(f);
                ol.did(s);
                //使用父类的引用指向子类对象
                Father ff=new Son();
                ol.did(ff);
        }
}

声明了一个Father 类，Son类继承自 Father 类并且在OverLoad1 类中声明了两个 did() 方法，方法入口参数分别为 Father 类型和 Son 类型，在主方法中分别通过不同的参数来调用这两个方法：

编译运行以上程序得到如下结果：

F:\gz\JAVA\gzhs>java OverLoad1
Father类型!
Son类型!
Father类型!

引用类型决定调用哪个重载方法

接口的声明和实现

接口是一系列方法的声明，是一些方法特征的集合。接口只有方法特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为功能

接口是组件化编程的一个重要内容，

public interface MyInterface {

}

定义接口

Java 接口的方法只能是抽象的和公开的，Java 接口不能有构造器，Java接口可以有公有的，静态的，和最终的3种属性。

①接口中的方法都是公共的，抽象的

②接口中的方法不能是静态的方法

③在接口中声明方法时，可以不显示地为方法签名输入 public 和 abstract 修饰符，编译器会自动为其加上

④接口中的所有变量都必须是公有的，静态的和最终的

⑤接口中的方法不能使用的修饰符有：final    native   strictfp    synchronized

⑥接口中只能声明常量，不能声明实例变量

⑦接口可以继承自一个或者多个其他接口，不能实现其他接口，接口类型可以被多态使用。接口中的方法都没有方法体。

实现接口

JAVA 是一种单继承的语言，一般情况下，解决的办法是给它的父类加父类，或者给它父类的父类加父类，直到移动到类等级结构的最顶端。

public interface MyInterface {

}

class MainClass implements MyInterface {

}

实现接口可以使用 implements 关键字，上面的程序是最简单的实现。

因为接口中没有定义任何方法，如果接口中定义了业务方法，则要实现此接口的类就必须实现接口中定义的方法，除非此类是抽象的：

public interface MyInterface {

        void method();

        void method1();

}

class MainClass implements MyInterface {

        public void method() {

        }

        public void method1() {

        }

}

接口的多重继承

和类的继承的规则不同，一个类只有一个直接父类，但可以实现多个接口，所以JAVA 接口比 JAVA 抽象类更抽象化

interface FatherInterface {
        void method2();
}
interface MyInterface extends FatherInterface {
        void method();
}
interface MyInterface1 {
        void method1();
}
abstract class MainClass2 implements MyInterface,MyInterface1 {
        public void method() {
        }
        public void method1() {
        }
        public void method2() {
        }
}

声明了一个FatherInterface 接口和一个 MyInterface1 接口， MyInterface 接口扩展自 FatherInterface 接口， MainClass2 类实现了 MyInterface 和 MyInterface1 接口

MainClass2 类 虽然是抽象类，可以不实现接口中的方法，但是上例中也都实现了这些接口中的办法。

一个类只能继承自一个类，但是可以设计实现多个接口，接口本身可以继承其他的接口，但是不能设计实现任何接口

接口和类不同，接口可以任意地扩展多个接口：

interface FatherInterface {

        void method2();

}

interface MyInterface {

        void method();

}

interface MyInterface1 extends FatherInterface,MyInterface {

        void method1();

}

封装类

基本数据类型可以通过强制类型转换来得到需要的值，而对于将基本数据类型转换为对象类型就只有通过JAVA 封装类来实现

封装类的简介

基本类型只能按值传递，而每个基本类型对应的封装类是按引用类型传递的。

创建封装器类对象

一种是使用new 关键字

除了Character 之外，所有的封装器类都提供了两个构造函数，一个是原始类型的构造函数，一个是 String 类型的构造函数

Integer i=new Integer();

Integer i=new Integer("100");

或者

Float f=new Float(3.14f)；

Float f=new Float("3.14f");

或者

Character c=new Character('c');

或者

Boolean b=new Boolean("true");

Boolean b=new Boolean("FALse");

另一种方法就是使用对象工厂——valueOf() 方法。大多数封装器类都提供了静态valueOf() 方法，两种方式都可以使用原始类型的参数。

而使用对象工厂valueOf() 方法还可以外加进制作为参数：

Integer i=Integer.valueOf("10010",2);

Integer i=Integer,valueOf("215");

或者

Float f=Float.valueOf("3.14f");

封装类的常用方法

可以将原始类型转换成对象类型，当需要把封装类的数值转换为原始类型时，则可以使用 xxxValue() 方法。

该方法的所有版本都是无参方法：

Integer i=new Integer(22);

short s=i.shortValue();

double d=i.doubleValue();

或者

Float f=new Float(3.14f);

short s=f.shortValue();

public class ParesEx {
        public static void main(String args[]) {
                Integer i=new Integer(22);
                //使用对象工厂方法创建封装器类对象
                Integer ii=Integer.valueOf(33);
                System.out.println("i="+i.intValue());
                System.out.println("ii="+ii.intValue());
                //parseXxx()方法
                try {
                      System.out.println("参数为:"+Integer.parseInt("44"));
                      System.out.println(Integer.parseInt("4a"));
                } catch (NumberFormatException nfe) {
                       System.out.println("数据格式错误!");
                }
        }
}

parseXxx() 方法将指定字符串转换为原始类型返回，以上实例通过调用封装器类的构造函数和 valueOf() 工厂方法创建封装器类对象，

在调用parseXxx() 方法将字符串转换为原始类型时可能会抛出 NumberFormatException 异常

编译运行后得到以下结果：

F:\gz\JAVA\gzhs>java ParesEx
i=22
ii=33
参数为:44
数据格式错误!

使用parseXxx() 方法时，如果输入的参数不是原始数据类型，则抛出 NumberFormatException 异常

toXxxString() 方法可以将十进制数转换成八进制或者十六进制数：

public class ToString {
        public static void main(String args[]) {
                //toString()方法
                Integer i=new Integer(22);
                Integer ii=Integer.valueOf(33);
                //打印结果
                System.out.println("i="+i.toString());
                System.out.println("ii="+ii.toString());
                //toXxxString()方法
                System.out.println("二进制表示为: "+Integer.toBinaryString(212));
                System.out.println("八进制表示为: "+Integer.toOctalString(212));
                System.out.println("十六进制表示为: "+Integer.toHexString(212));
        }
}

编译运行以上程序将得到如下结果：

F:\gz\JAVA\gzhs>java ToString
i=22
ii=33
二进制表示为: 11010100
八进制表示为: 324
十六进制表示为: d4

LINUX

watch     将结果输出到标准输出设备

screen   多重视窗管理程序

apache  服务器应用命令

HTML5

确定自然的分块

<body>

<div>

Header content goes here.

</div>

<div>

Body copy goes here.

</div>

<div>

Footer content goes here.

</div>

</body>

<section> </section> :用于分组与主题相关的内容，比如，一本书中的各章，通常可以作为数据库的一部分

<header></header>:用于容纳文档或部分的标题，比如，标题、副标题、标语（tagline）和导航

<footer></footer>:用于容纳文档或部分的页脚，比如，联系信息和版权数据

<aside></aside>:用于分组与主体无关的内容，比如，重要的引文、传记信息和相关链接

<nav></nav>:用于容纳文档或部分的重要导航元素

<article></article>:用于容纳可聚合(syndication)的内容

<div></div>:用于容纳通用的内容部分，主要出于对该部分内容应用样式表的目的

header元素和 footer元素

在单个页面上，实际上可以存在多个header 元素和 footer 元素

<header>

Header content goes here

</header>

<footer>

Footer content goes here

</footer>

要同时具有开始标记和结束标记。要在header 和 footer 中显示内容，则放在开始标记与结束标记之间

尽管与<head>元素在名称上类似，但是 header 元素与<head>元素并没有任何关系。header 放在<body>内容之中，而<head>元素放在Web页面的<body>之外

nav 元素

既可以单独使用，也可以放在其他部分之内。然而，将页面上的每一个超链接都包含在一个 nav 容器之中也并无必要。<nav> 标记中只应该包含最重要的导航块：

<nav>

Nav content goes here

</nav>

Both opening and closing tags are required.

aside元素

内容一般为重要的引文、传记信息和相关的广告或链接

<aside>

Aside content goes here

</aside>

同样需要开始标记和结束标记

section 和 article 元素

二者很容易混淆，都可以包含相同类型的内容。但仅有article 元素指定具有聚合内容的用途，

在Web中，聚合指的是内容对其他Web网站可用，一边复制这些内容

section 元素更适合表示故事中的章节:

<section>

Section content goer here

</section>

<article>

Article content goes here

</article>

在单个页面中，可存在多个 section 和 article 元素

根据使用情形，这两个元素中的任意一个都可以嵌套在另一个元素中：

<article>

        <header>My Book</header>

        <section>Chapter 1 goes here</section>

        <section>Chapter 2 goes here</section>

        <section>Chapter 3 goes here</section>

</article>

section 元素是专门为要储存在数据库中的一块内容而创建的，因此不应该将 section 元素作为容纳内容的通用容器。如果仅仅是出于定义样式的目的而寻找一个通用容器元素来包含内容，建议使用  div  元素。

设置标题

使用标题标记将自动在标题之前和之后添加换行符，因为这些标题标记都是块级(block-level)容器元素。但在样式表中也可以修改标题两侧的间距。

在section容器元素中如何混合使用标题元素：

<article id="scienceBook">

        <header>Science</header>

        <section class="introChapter">

                <h1>Chapter 1 Heading</h1>

                First part of chapter 1 goes here

                <h2>Chapter 1 Sub Heading<h2>

                Second part of chapter 1 goes here

        </section>

        <section class="normalChapter>

                <h1>Chapter 2 Heading</h1>

                First part of chapter 2 goes here

                <h2>Chapter 2 Sub Heading</h2>

                Second part of chapter 2 goes here

        </section>

</article>

定义标题的样式

先用标题标记告诉浏览器将哪一块文本作为标题，然后使用CSS定义标题的样式

因此，只需使用<h3 style="text-align:right;">这样的内联样式，就可以快速的调整标题的对齐方式：

<style type="text/css">

h3 {text-align: right;}

</style>