java出学者教程第四课(只适用于出学着)
来源：互联网 发布：淘宝的运作模式 编辑：程序博客网 时间：2024/06/04 18:43
Lesson4
在java中,boolean,byte,short,int.long,char,float,double这八种基本数据类型,其余的都是引用类型.
“==”是比较两个变量的值是否相等.
“equals”是比较两个对象变量所代表的对象的内容是否相等.
StringBuffer可以代替String,String在换引用的时候,内存就被浪费产生新的空间来存放新的字符,所以用StringBuffer来搞定这个方法.
Str=new StringBuffer().append(“a”).append(“b”).append(“c”).tostring()
Str=”abc” 等同的效果,但是可以不占用过多内存.
StringBuffer sb=new StringBuffer();
sb. append(“a”).append(“b”).append(“c”)
System.out.println(sb.tostring());
sb.dellete(4,8);删除字符串中固定的字符
asdfghjkl,这个删除的是fghj,这四个,删除的位置意义为4>=x<8;
x和y值是不会互换的,因为在java中传参时都是以传值的方式进行的,对于基本数据类型传递的是数据的拷贝;对于引用的类型传递是引用的拷贝.
类型的引用会直接改变引用到的堆内存的值,所以可以互换.
对象的克隆;
为了获取对对象的一个拷贝,我们可以利用Object类的clone()方法来实现.
在派生类来覆盖某个基类的clone()方法,并声明为public.
在派生类的clone()方法中,调用super.clone().
在派生类中实现Cloneable接口.
如果要用到clone(),就必须去实现Cloneable(这是表示接口,没有任何抽象方法)接口.,要不会抛出CloneNotSupportdeException.
这是普通克隆
class clonetest{
public static void main(String [] args){
Student s1= new Student("zhangsan",18);
//s1.name="zhangsan"
//s1.age="11"
Student s2= (Student)s1.clone(); //因为s1.clone();返回的是Object类型,所以用(Student)来作强制类型转换.
s2.name="zhangsanaaaaaaaa";
s2.age=11;
System.out.println(s1.name+s1.age);
System.out.println(s2.name+s2.age);
}
}
//克隆的四个步骤
class Student implements Cloneable{//在派生类中实现Cloneable接口.
String name;
int age;
Student(String name,int age){
this.name=name;
this.age=age;
}
public Object clone(){//在派生类来覆盖某个基类的clone()方法,并声明为public.
Object o=null;
try{
o=super.clone();//在派生类的clone()方法中,调用super.clone().
}catch(CloneNotSupportedException e){
e.toString();//如果要用到clone(),就必须去实现Cloneable(这是表示接口,没有任何抽象方法)接口.,
//要不会抛出CloneNotSupportdeException.
}
return o;
}
}
这是浅克隆:
class clonetest{
public static void main(String [] args){
Professor p=new Professor("erbi",1111);
Student s1= new Student("zhangsan",18,p);
//s1.name="zhangsan"
//s1.age="11"
Student s2= (Student)s1.clone(); //因为s1.clone();返回的是Object类型,所以用(Student)来作强制类型转换.
s2.name="zhangsanaaaaaaaa";
s2.age=11;
System.out.println(s1.name+s1.age);
System.out.println(s2.name+s2.age);
System.out.println(s1.p.name+s1.p.age);//对对象的引用的克隆是不会成功,java默认为浅克隆的.
System.out.println(s2.p.name+s2.p.age);
}
}
class Professor{
String name;
int age;
Professor(String name,int age){
this.name=name;
this.age=age;
}
}
//克隆的四个步骤
class Student implements Cloneable{//在派生类中实现Cloneable接口.
String name;
int age;
Professor p;
Student(String name,int age,Professor p){
this.name=name;
this.age=age;
this.p=p;
}
public Object clone(){//在派生类来覆盖某个基类的clone()方法,并声明为public.
Object o=null;
try{
o=super.clone();//在派生类的clone()方法中,调用super.clone().
}catch(CloneNotSupportedException e){
e.toString();//如果要用到clone(),就必须去实现Cloneable(这是表示接口,没有任何抽象方法)接口.,
//要不会抛出CloneNotSupportdeException.
}
return o;
}
}
输出结果:
zhangsan18
zhangsanaaaaaaaa11
erbibibibi1
erbibibibi1把s1引用的对象也改了,就是说克隆出来的对象把被克隆的对象的引用也改了,这为浅克隆.
如何做深克隆
对象的引用是复制了一份对象的拷贝,就是说对象指向的是同一个内存空间
数组的相关操作
在java中,所有的数组都有一个缺省的属性length,用于获取数组中元素的个数.
数组的复制:System.arraycopy().
数组的排序:Arrays.sort().
在已排序的数组中查找莫元素:Arrays.binarySearch()
数组的拷贝:
class Arraytest{
public static void main(String [] args){
int[] num1=new int[]{1,2,3};
int[] num2=new int[3];
System.arraycopy(num1,0,num2,0,num1.length);//参数为:原数组,从原数组哪个位置开始拷贝,要拷贝到的数组,从哪位置进行
//存放数据,被拷贝数组的长度.
for(int i=0;i<num1.length;i++){
System.out.println(num1[i]);
System.out.println(num2[i]);
}
}
}
对象数组的拷贝:
class arraytest{
public static void main(String [] args){
/*int[] num1=new int[]{1,2,3};
int[] num2=new int[3];
System.arraycopy(num1,0,num2,0,num1.length);
for(int i=0;i<num1.length;i++){
System.out.println(num2[i]);
}*/
Point [] p1=new Point []{new Point(1,1),new Point(2,3),new Point(3,4)};
Point [] p2=new Point [3];
System.arraycopy(p1,0,p2,0,p1.length);
for(int i=0;i<p1.length;i++){
//System.out.println(p1[i]);
//System.out.println(p2[i]);
System.out.println("x="+p1[i].x+"y="+p1[i].y);
System.out.println("x="+p2[i].x+"y="+p2[i].y);
}
}
}
class Point{
int x;
int y;
Point (int x,int y){
this.x=x;
this.y=y;
}
}
对象数组复制的是引用,所以改变数组的属性值,会影响复制出去的对象,因为他们指向的是同一个内存空间.
数组排序:
import java.util.*;
class sorttest{
public static void main(String [] args){
int [] num=new int[]{2,5,4,1,3};
Arrays.sort(num);
for(int i=0;i<num.length;i++){
System.out.println(num[i]);
}
}
}
在已排序的数组中查找莫元素:Arrays.binarySearch()
import java.util.*;
class sorttest{
public static void main(String [] args){
int [] num=new int[]{2,5,4,1,3};
Arrays.sort(num);
for(int i=0;i<num.length;i++){
System.out.println(num[i]);
}
int a=Arrays.binarySearch(num,4);
System.out.println(num[a]);
}
}
对象数组排序:
import java.util.*;
class brrytesto{
public static void main(String [] args){
/*int[] num1=new int[]{1,2,3};
int[] num2=new int[3];
System.arraycopy(num1,0,num2,0,num1.length);//参数为:原数组,从原数组哪个位置开始拷贝,要拷贝到的数组,从哪位置进行
//存放数据,被拷贝数组的长度.
for(int i=0;i<num1.length;i++){
System.out.println(num1[i]);
System.out.println(num2[i]);
}*/
Student [] ss= new Student []{new Student(1,"zhangsan"),new Student(3,"lishi"),new Student(3,"wangwu")};
Arrays.sort(ss);
for(int i=0;i<ss.length;i++){
System.out.println(ss[i]);
}
}
}
class Student implements Comparable{
int num;
String name;
Student(int num,String name){
this.num=num;
this.name=name;
}
public String toString(){
return "number="+num+"name="+name;
}
public int compareTo(Object o){
Student s=(Student)o;
return num>s.num ? 1 : (num==s.num ? 0:-1);
}
}
对数组排序要实现Comparable接口和里边的抽象方法才可以.
数组搜索要在排好序的数组中进行.
有的时候调函数,应该传的是引用类型的参数,可是我们想传的确是基本类型的值,就可以用封装类.
所有封装类都是只读类.
class test{
public static void main(String [] args){
int i=10;
Integer n=new Integer(i);
int j=n.intValue();
System.out.println("j="+j);
System.out.println("j="+j+j);
String str=n.toString();
System.out.println(str+1);
String s="4439834";
System.out.println(Integer.valueOf(s));
}
}
Class类
class Classtest{
public static void main(String [] args){
Point pt= new Point();
Class c1=pt.getClass();
System.out.println(c1);
System.out.println(c1.getName());
try{
Class c2=Class.forName("Point");
System.out.println(c2.getName());
}catch(Exception e){
System.out.println(e);
}
Class c3=Point.class;
System.out.println(c3.getName());
Class c4=int.class;
System.out.println(c4.getName());
Class c5=Integer.TYPE;
System.out.println(c5.getName());
}
}
class Point{
int x,y;
}
class Classtest{
public static void main(String [] args){
System.out.println("before new Point");
new Point();
System.out.println("after new Point");
try{
Class.forName("line");
}catch(Exception e){
System.out.println("fasdf");
}
}
}
class Point{
int x,y;
static {
System.out.println("loading...Point");
}
}
class line{
static {
System.out.println("loading...line");
}
}
newInstance():当不知道类名字的时候去创建类的实例
class Classtest{
public static void main(String [] args){
if(args.length!=1){
return;
}
try{
Class c=Class.forName(args[0]);
Point pt=(Point)c.newInstance();
pt.output();
}
catch(Exception e){
System.out.println(e);
}
}
}
class Point{
int x,y;
static {
System.out.println("loading...Point");
}
void output(){
System.out.println("x="+x+","+"y="+y);
}
}
class line{
static {
System.out.println("loading...line");
}
}
newInstance():调用类中缺省的构造方法,要求是不带参数的
class Classtest{
public static void main(String [] args){
if(args.length!=1){
return;
}
try{
Class c=Class.forName(args[0]);
Point pt=(Point)c.newInstance();
pt.output();
}
catch(Exception e){
System.out.println(e);
}
}
}
class Point{
int x,y;
static {
System.out.println("loading...Point");
}
void output(){
System.out.println("x="+x+","+"y="+y);
}
Point(int x,int y){
this.x=x;
this.y=y;//多了这部分就会出现异常,因为需要调用缺省的//构造方法
}
}
class line{
static {
System.out.println("loading...line");
}
}
java.lang.reflect为java.lang的子类,也需要导入的,不能直接使用.
import java.lang.reflect.*;反射机制类.
class Classtest{
public static void main(String [] args){
if(args.length!=1){
return;
}
/*try{
Class c=Class.forName(args[0]);
Point pt=(Point)c.newInstance();
pt.output();
}
catch(Exception e){
System.out.println(e);
}*/
try{
Class c=Class.forName(args[0]);
Constructor [] cons=c.getDeclaredConstructors();
for(int i=0;i<cons.length;i++){
System.out.println(cons[i]);//打印类中所有构造方法
}
Method [] ms=c.getDeclaredMethods();
for(int j=0;j<ms.length;j++){
System.out.println(ms[j]);打印类中所有函数
}//重点部分
}
catch(Exception e){
System.out.println(e);
}
}
}
class Point{
int x,y;
static {
System.out.println("loading...Point");
}
void output(){
System.out.println("x="+x+","+"y="+y);
}
Point(int x,int y){
this.x=x;
this.y=y;
}
Point(){
}
}
class line{
static {
System.out.println("loading...line");
}
}
import java.lang.reflect.*;用反射函数调用带参数的类
class Classtest{
public static void main(String [] args){
if(args.length!=1){
return;
}
/*try{
Class c=Class.forName(args[0]);
Point pt=(Point)c.newInstance();
pt.output();
}
catch(Exception e){
System.out.println(e);
}*/
try{
Class c=Class.forName(args[0]);//命令行传进来对象做参数
Constructor [] cons=c.getDeclaredConstructors();//通过该方法得到此对象里的构造函数的个数
/*for(int i=0;i<cons.length;i++){
System.out.println(cons[i]);
}
Method [] ms=c.getDeclaredMethods();
for(int j=0;j<ms.length;j++){
System.out.println(ms[j]);
}*/
Class [] params=cons[0].getParameterTypes();//通过该方法知道构造函数里参数类型信息
Object [] paramValues=new Object [params.length];//将参数一一传给Object
for(int i=0;i<params.length;i++){
if(params[i].isPrimitive()){
paramValues[i]=new Integer (i+3);
}
}
Object o=cons[0].newInstance(paramValues);
Method [] ms=c.getDeclaredMethods();
ms[0].invoke(o,null);
}
catch(Exception e){
System.out.println(e);
}
}
}
class Point{
int x,y;
static {
System.out.println("loading...Point");
}
void output(){
System.out.println("x="+x+","+"y="+y);
}
Point(int x,int y){
this.x=x;
this.y=y;
}
/*Point(){
}*/
}
class line{
static {
System.out.println("loading...line");
}
}
类 Runtime:
public class Runtime
extends Object
每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。
应用程序不能创建自己的 Runtime 类实例。
import java.io.*;
class Runtimetest{
public static void main(String [] args){
Runtime rt=Runtime.getRuntime();
long free=rt.freeMemory();
long max=rt.maxMemory();
long to=rt.totalMemory();
System.out.println(free);
System.out.println(max);
System.out.println(to);
try{
Process p=rt.exec("java Arraytest");
InputStream is=p.getInputStream();
int data;
while((data=is.read())!=-1){
System.out.print((char)data);
}
//rt.exec("java Runtimetest");
}
catch(Exception e){
e.printStackTrace();
}
}
}
Runtime类是使用单例模式的一个例子.
什么叫设计模式:
在我们进行设计程序的时候,逐渐形成了一些典型问题和问题的解决方案,这就是软件的设计模式.
每一个模式描述了在我们程序设计中经常发生的问题,以及该问题的解决方案.
当我们碰到模式所描述的问题,就可以用相应的解决方法去解决这个问题,这就是设计模式.
单例类(Singleton):模式
(1)一个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这类类称为单例类
(2)单列类一个重要的特点就是类的构造方法是私有的,从而避免了外部程序利用够杂方法,创建多个实例.
单列类的实现:
class Sing{
private static final Sing s=new Sing();
private Sing(){}
public static Sing getInstance(){
return s;
}
}
- java出学者教程第四课(只适用于出学着)
- 出学者
- 出学者的茫然~~
- java学习笔记(只适用于初学者)
- AnySim一键解锁教程 只适用于新iPhone
- 出学者入门：从java程序中调用其它程序 — IT技术 - 赛迪网
- 设置Eclipse智能提示（似乎只适用于.java文件）
- QT+网络编程。。适合出学者
- Android实战简易教程-第四十一枪（显示倒计时的Button-适用于获取验证码）
- IntelliJ IDEA详细配置和使用教程(适用于Java开发人员)
- string----------只适用于string操作
- JAVA自学系列教程：第四课，JSP内置对象及网站案例(第四节 session对象)
- 东方学者眼里的日本-第三只眼看日本
- JavaScript高级教程- 第四课
- Android OpenGL教程-第四课
- Android OpenGL教程-第四课
- Android OpenGL 教程 第四课
- 滚动栏 样式，只适用于 IE
- 我开始写文章
- STL vector 容器介绍
- 下拉多选框的应用
- Enterprise LibraryV1.0-异常处理应用程序块使用说明
- YUV
- java出学者教程第四课(只适用于出学着)
- java脚本实现下拉框和文本框的数据交换
- 自动挂载windows分区
- 收集一些常用的正则表达式。
- 在Flash中播放flv视频
- 开心四人行
- Java日期操作常用方法
- uboot终于能从flash上引导linux内核了，但是内核启动又出现了问题
- ASP连接MYSQL代码
