4.21

JAVA

实践练习

错误运行：public static void main(String args[]){
                //创建对象并调用方法
                new Student(). aa();
                int i=new Student(). sage;
                //打印
                System.out.println("i="+i);
        }
}
class Student {
        // Student类
        //声明成员变量并初始化
        public int sage=22;
        //声明成员办法
        public void aa() {
                //打印
                System.out.println("aa");
        }
}

解决办法，将class Student 类与第一段代码分开编译

后续的包的引用以及this 关键字中多处练习遇到问题

运算符实践

public class MainClass {
        public static void main(String args[]) {
                int i=88;
                int j=2;
                double d1=99.9;
                double d2=11.1;
                System.out.print("i*=j等于"+(i*=j));
                System.out.print("i+=j等于"+(i+=j));
                System.out.print("i-=j等于"+(i-=j));
                System.out.print("i/=j等于"+(i/=j));
                System.out.print("d1/=d2等于"+(d1/=d2));
                System.out.print("i%=j等于"+(i%=j));
                System.out.print("d1%=d2等于"+(d1%=d2));
                System.out.print("i>>=j等于"+(i>>=j));
                System.out.print("i<<=j等于"+(i<<=j));
                System.out.print("i>>>=j等于"+(i>>>=j));
                System.out.print("i&=j等于"+(i&=j));
                System.out.print("i|=j等于"+(i|=j));
                System.out.print("i^=j等于"+(i^=j));
        }
}

初试各种赋值运算符的例子，声明了两个int 类型的变量和两个 double 类型的变量 分别进行各种赋值运算，然后打印出结果，如下：

i*=j等于176

i+=j等于178

i-=j等于176

i/=j等于88

d1/=d2等于9.0

i%=j等于0

d1%=d2等于9.0

i>>=j等于0

i<<=j等于0

i>>>=j等于0

i&=j等于0

i|=j等于2

i^=j等于0

首先我们尝试如下编辑，

public class MainClass1 {
        public static void main(String args[]) {
                byte i=88;
                byte j=2;
                byte b=i+j;
                System.out.println(b);
        }
}

编译以上代码将得到一下错误信息：

MainClass1.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失
                byte b=i+j;
                        ^
1 个错误

修改前面的程序如下：

public class MainClass1 {
        public static void main(String args[]) {
                byte i=88;
                byte j=2;
                int b=i+j;
                System.out.println(b);
        }
}

这时以上代码就能很好的编译且运行：F:\gz\JAVA\Ysf>javac MainClass1.java

F:\gz\JAVA\Ysf>java MainClass1
90

如下这中代码也能通过编译：byte b=20;

                                                b+=20;

牵扯到复合赋值运算符，上面的代码相当于：byte b=20;

                                                                        b=(byte)(b+20);

复合赋值运算符在进行运算以后，会自动将结果转换为 b  的数据类型。

此外，还有浮点数的赋值，例如：float f=22.2

public class MainClass2 {
        public static void main(String args[]) {
                float f=22.2;
                System.out.println(f);
        }
}

编译以上代码将得到一下错误信息：

MainClass2.java:3: 错误: 不兼容的类型: 从double转换到float可能会有损失
                float f=22.2;
                        ^
1 个错误

编译器认为这个操作也可能丢失精度，因为22.2默认是double 类型的.

修改上面的代码如下：

public class MainClass2 {
        public static void main(String args[]) {
                float f=22.2F;
                float f1=22.2F;
                float f2=(float)22.2;
                System.out.println(f);
        }
}

就可以很好的编译

对象引用的赋值。可以把一个新创建的对象赋值给这个对象的引用变量，例如Object obj=new Object();

如上的代码将完成下面三个操作：

①首先创建一个名称为obj 的 Object 类型的引用变量

②然后在堆上创建一个 Object 对象

③最后把新创建的Object 对象赋值给引用变量 obj

实践给引用变量赋值：

class Father {

}
class Son extends Father {

}
public class MainClass3 {
        public static void main(String args[]) {
                Father f=new Son();
                Son s=new Father();
        }
}

按上述代码编辑编译会输出一下信息：

MainClass3.java:10: 错误: 不兼容的类型: Father无法转换为Son
                Son s=new Father();
                      ^
1 个错误

因为不能使用子类引用指向父类对象。可以将子类看作是父类类型，但是不能将父类看作是子类类型。

修改以上代码如下：

class Father {

}
class Son extends Father {

}
public class MainClass3 {
        public static void main(String args[]) {
                Father f=new Father();
                Son s=(Son) f;
        }
}

编译成功，结果如下：

F:\gz\JAVA\Ysf>java MainClass3
Exception in thread "main" java.lang.ClassCastException: Father cannot be cast t
o Son
        at MainClass3.main(MainClass3.java:10)

在JAVA 语言汇总，字符串被作为String 类的对象来处理，而且String 类的对象的指是永不可变的：

public class MainClass4 {
        public static void main(String args[]) {
                String s="Java String";
                //将s的值赋给s1引用变量
                String s1=s;
                //打印s1的值
                System.out.println(s1);
                //将s1的内容都转成大写
                s1.toUpperCase();
                //再次打印s1的值
                System.out.println(s1);
        }
}

编译结果如下：

F:\gz\JAVA\Ysf>java MainClass4
Java String
Java String

可以看出，在调用s1上的toUpperCase() 方法将其内容都转换成大写之后，s1的内容并没有改变，这是因为调用toUpperCase()方法得到的新的String 对象没有再赋值给任何引用变量，这个新建的对象立刻被废弃。

算术运算符

简单的算术运算例子，先声明两个int 类型和两个double 类型的成员变量，并对其做算术运算：

public class MainClass5 {
        public static void main(String args[]) {
                //整数运算
                int i=66;
                int j=11;
                System.out.println("i+j="+(i+j));
                System.out.println("i-j="+(i-j));
                System.out.println("i*j="+(i*j));
                System.out.println("i/j="+(i/j));
                System.out.println("==========");
                //小数运算
                double d=52.6;
                double dd=15.1;
                System.out.println("d+dd="+(d+dd));
                System.out.println("d-dd="+(d-dd));
                System.out.println("d*dd="+(d*dd));
                System.out.println("d/dd="+(d/dd));
        }
}

编译结果如下：

F:\gz\JAVA\Ysf>java MainClass5
i+j=77
i-j=55
i*j=726
i/j=6
==========
d+dd=67.7
d-dd=37.5
d*dd=794.26
d/dd=3.4834437086092715

生成一个对象的过程也被称为实例化，所以一个对象就是一个实例。stu1 和 stu2 都是对象名，对象名是用来引用对象的，对象里的变量和方法可以通过对象名来引用，如下程序所示：

public class Test16 {
        //主方法
        public static void main(String args[]) {
                //创建两个Student对象
                Student st1=new Student();
                Student st2=new Student();
                //使用对象引用访问对象成员
                st1.aa();
                int i=st2.sage;
                System.out.println("i="+i);
        }
}
class Student {
        //Student类
        //声明成员变量并初始化
        public int sage=22;
        //声明成员办法
        public void aa() {
                //打印
                System.out.println("aa");
        }
}

以上代码中直接使用“引用名.成员名”调用其类的成员或方法。编译以上程序将会显示如下信息：

F:\gz\JAVA\Test>java Test16
aa
i=22

this 关键字，this 是指当前对象自己，当在一个类中需要明确指出使用对象自己的变量或函数时就应该加上this  引用。如下：

public class Test17 {
        //声明成员变量并初始化
        static int i=10;
        //主方法
        public static void main(String args[]){
                //声明局部变量并初始化
                int i=12;
                //打印
                System.out.println("i="+i);
        }
}

以上代码中，在Test17类中定义了与成员变量同名的局部变量i，在局部变量  i  作用的范围内成员变量 i   将被隐藏

编译运行以上程序将会得到如下信息：

F:\gz\JAVA\Test>java Test17
i=12

当需要输出与局部变量同名的成员变量时，需要使用this 关键字，如下:

public class Test18 {
        //声明成员变量并初始化
        static int i=10;
        //主方法
        public static void main(String args[]) {
                //创建对象并调用方法
                new Test18().ii();
        }
        //声明成员办法
        public void ii() {
                //声明局部变量并初始化
                int i=12;
                //打印
                System.out.println("i="+this.i);
        }
}

在局部变量i  的作用范围内要输出成员变量 i  时，必须使用 this.i。

编译运行以上程序得到如下信息：

F:\gz\JAVA\Test>java Test18
i=10

HTML5

组织文本。

段落：

p  元素的具体功能是作为段落的一个容器，所以在段落的开始处使用p 元素的开始标记 <p>,段落的结尾处使用结束标记</p>。

举例：

<div class="nurseryRhyme">
<p>Jack and Jill went wp a hill</p>
<p>To fetch a paill of water</p>
<p>Jack fell down and broke his crown</p>
<p>And Jill came tumbling after</p>
</div>

需要注意的是，默认情况下p 标记会在段落前和段落后各强制产生一个空行

缩进，要缩进一个段落的第一行，可以在样式表中使用 text-indent 属性

换行符。br 标记可用来添加换行符

br标记会导致浏览器在该行上停止输出文本，并换到页面上的下一行继续输出。

<p>
Jack and Jill went up a hill <br>
To catch a pail of water <br>
Jack fell down and broke his crown <br>
And Jill came tumbling after <br>
</p>

<p>
Jack and Jill went up a hill<br>To catch a pail of water<br>Jack fell down and broke his crown<br>And Jill came tumbling after<br>
</p>

如上两种方式都可以实现换行

当需要在内容上空出多行时，只需要简单的在HTML 文件中重复添加多个br 标记即可：

<p>

Jack and Jill went up a hill <br><br><br><br> To fetch a pail of water

</p>

预格式化

pre    是 preformat(预格式化)的简写，pre 标记将完全按照输入的文本格式在浏览器中将其呈现出来，

但是：

①pre 通常以等宽字体来显示文本，例如Courier字体，可使文本看起来有种类似于打字机打印的效果。

②pre 标记并不保证按照设想的方式输出。即使在pre 标记中可以使用Tab键来格式化文本，但是不同的浏览器可能会将一个 Tab 键解释为不同数量的空格字符，这可能会导致创建的表哥不能正确呈现

引用块 

BOX 属性

LINUX

adduser  新增使用者帐号或更新预设的使用者资料

chfn   提供使用者更改个人资讯，用于 finger and mail username

useradd  用来建立用户帐号。帐号建好之后，再用passwd设定帐号的密码．而可用userdel删除帐号。使用useradd指令所建立的帐号，实际上是保存在/etc/passwd文本文件中

date   用来显示或设定系统的日期与时间，在显示方面，使用者可以设定欲显示的格式，格式设定为一个加号后接数个标记:又分为时间方面和日期方面

exit   执行exit可使shell以指定的状态值退出。若不设置状态值参数，则shell以预设值退出。状态值0代表执行成功，其他值代表执行失败。exit也可用在script，离开正在执行的script，回到shell

finger    可以让使用者查询一些其他使用者的资料

fwhios    本指令的功能有点类似finger指令，它会去查找并显示指定帐号的用户相关信息。不同之处在于fwhois指令是到Network Solutions的WHOIS数据库去查找，该帐号名称必须有在上面注册才能寻获，且名称没有大小写的差别

sleep   可以用来将目前动作延迟一段时间,例如：sleep 5m     休眠五分钟

suspend   shell内建指令，可暂停目前正在执行的shell。若要恢复，则必须使用SIGCONT信息

groupdel   需要从系统上删除群组时，可用groupdel(group delete)指令来完成这项工作。倘若该群组中仍包括某些用户，则必须先删除这些用户后，方能删除群组

kill   删除执行中的程序或工作

last   用于显示系统开机以来获是从每月初登入者的讯息

lastb   单独执行lastb指令，它会读取位于/var/log目录下，名称为btmp的文件，并把该文件内容

记录的登入失败的用户名单，全部显示出来

login   让用户登入系统，您亦可通过它的功能随时更换登入身份。在Slackware发行版中 ，您可在指令后面附加欲登入的用户名称，它会直接询问密码，等待用户输入。当/etc目录里含名称为nologin的文件时，系统只root帐号登入系统，其他用户一律不准登入

logname   显示目前用户的名称

logout   让用户退出系统，其功能和login指令相互对应

ps   用于显示当前进程 (process) 的状态