JAVA笔记

1, 移位符,A >>,B>>>(无符号移位),等移位后A的值不会变.如果要求2的N次方时,就可以直接左移N位了

.

2.+运算符,除了能将字符串相加外,还能将非字符串转化为字符串.   “A”+123 结果为”A123”

 

3.比较运算符:<,>,>=,````````instanceof.    “abc” instanceof string ==true

 

 

4.浮点数的比较时不用==,因为它有精度,只能用一个范围在比较.   比如求一个二次方程的根的时候,判断一个浮点数的根的大小时只能用一个范围,判断一个根A是否为0时要:A>0.001(或其它的数)

 

5.数组有方法java.util.Arrays.sort(int[]),system. void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)用于对数组排序和拷贝.

6.方法中定义的变量在使用前要先初始化…而在于类中定义的变量系统会自动给初始化…方法中的变量与类中的变量相同时,方法访问到的是方法中的变量.函数中的形参相当于该函数中的局部变量.

 Person p1=new person();//实例化person为p1,为之分配一段内存.

 Person p2=p1;// p2指向p1,这时两个都指导向同一内存了..

7.对象的比较:;  equals() //比较对象中的内容. 等号 是指值相等,比较各种型的数时,都是这样的..在对象中用等号时也是这样了,对象一=对象二,因为对象是指向内存中为之分配空间的首址,所以两都间用等号,就是把两个指向同一地址…

   string s1=new string(“asd”);

   string s2=new string(“asd”);

string s3=s2;

   s1==s3----àtrue//都指向同一地址

   s1==s2.----àfalse//指向的不同的内存单元,故这两个值是不等的.

   S1.equals(s2)------àtrue..//比较的是其中的内容.

    EQUALS比较的内容是你自己定义的,, 没有定义的话，equals的功能和＝＝一样

   数组也是对象.,但是他没有equals(),,但是有arrays.equals()

所有的对象都继承自OBJECT（根类），在根类中equals()方法的相等是指两对象A，B完全相同（A==B），也是指其为同一对象实例，而不是指对象所包含的内容一样，仅管A==B时两者包含的内容一定是一样的。如果其子类没有OVERRIDE此方法，则用equals()方法时，是用的根类中的方法。字符串string就是覆盖了根类中的方法，在字符串中的相等是指其包含的内容相等。很多类覆盖了此方法时都是指其包含的内容相等。

JDK中的（While creating your new equals method, you need to keep the following requirements in mind:

• The method must consistently return the same value for any single comparison of objects x and y no matter how many times the comparison is run, assuming that no data changes in x and y.

• The method should be symmetric so that x.equals(y) returns the same result as y.equals(x).

• The method should be transitive so that if x.equals(y) and y.equals(z) returns true, then z.equals(x) also returns true.

• Whenever the comparison is against a null value, the method should always return false—i.e., (x.equals(null) == false) should be true for all types of x.

• The method should be reflexive so that x.equals(x) is always true.

Don't forget to override the implementation of hashCode( ) when you override equals( ). There is a contract between these two methods that says that any objects evaluating as equivalent must also return the same hash code. For more information on this contract, see the Javadoc for java.lang.Object.equals( ).

 

The overridden equals( ) method ensures that collections that are not supposed to contain duplicates do indeed prevent them. It also illustrates an important concept in programming. Two objects are said to be equal in identity if they are the same object instance, whereas two objects are said to have equality if they contain the same data.

）在java.lang.Comparable接口中，其方法public int compareTo(Object o)是指内容相等。The compareTo( ) method has a number of requirements similar to the equals( ) method:

• Like the equals( ) method, the compareTo( ) method must return the same value for any single comparison of objects x and y no matter how many times the comparison is run, assuming that no data changes in x and y.

• The method should be transitive—i.e., if object x is comparatively greater than object y, and object y is comparatively greater than object z, object x should be greater than object z. This is generally written using the following mathematical notation:

If x > y and y > z then x > z

• The method must ensure that the comparison is consistent. For example, if x.compareTo(y) yields -1, then y.compareTo(x) should yield 1.

• The method should be reflexive so that x.compareTo(x) always returns 0.

• It is recommended that objects that are comparatively 0, but are not necessarily equals( ), indicate this in the documentation to the class.

8.构造函数::当类没有显式的提供构造函数的时候,系统会自动为之提供一个无参的构造函数.一旦类提供了构造函数的时候,系统就不会再为之提供一个无参的构函了.

9.this表示当前对象…this(),表示当前类的构造函数(如果构函中有参数,则this()中也有参数)..super()表示父类的构造函数..

     一、基础知识： 

1、super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）。 

2、this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）； 

3、super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时）。 

如：super.变量名 

super.成员函数据名（实参） 

4、this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）。 

二、应用实例： 

class Point 

{ private int x,y; 

public Point(int x,int y) 

{ 

this.x=x; //this它代表当前对象名 

this.y=y; 

} 

public void Draw() 

{ 

} 

public Point() 

{ 

this(0,0); //this（参数）调用本类中另一种形成的构造函数 

} 

} 

class Circle extends Point 

{ 

private int radius; 

public circle(int x0,int y0, int r ) 

{ 

super(x0,y0); //super（参数）调用基类中的某一个构造函数 

radius=r; 

} 

public void Draw() 

{ 

super.Draw(); //super它引用当前对象的直接父类中的成员 

drawCircle(); 

} 

} 

10.finalize()方法是每个类都有的方法,在垃圾回收器回收(system.gc()些函数是启动垃圾回收器)之前调用的..垃圾回收器启动具有不可预测性,所以可以自己写这个函数.

11.类中基本变量的传递:实参的值不改变. 基本类型传递的是其数值.. 

   类中对象的传递::相当于指针,,实参会改变..数组和对象的值都是一个地址,指向内存为之分配的空间.(JAVA中没有指针,但是其功能相当于指针).所以数组和对象传的都是地址,传递后形参和实参都指向同一内存单元..

public class HelloWorld

{

         int x;

         public static void main(String[]args)

         {                

                  int x=3;

                  System.out.println("原来的X="+x);

                  HelloWorld obj1=new HelloWorld();

                 // obj1.change(x);//基本类型的传递.

                 // System.out.println("基本类型的传递X="+x);//不改变实参的值.,为3

                  obj1.change(obj1);//对象的传递

                  System.out.println("对象的传递X="+obj1.x);//值为5

                  HelloWorld obj2=new HelloWorld();

                  obj2.x=3;

                  obj2.change1(obj2);//对象的传递

                  System.out.println("对象的传递,X="+obj2.x);//值为3..但是函数中又新建了一个对象.

                                               //所以实参和形参指向的不是同一内存单元了.

         }

         public void change(int x)

         {

                 x=5;

         }

         public void change(HelloWorld obj)

         {

                 obj.x=5;

         }

         public void change1(HelloWorld obj)

         {

                 obj=new HelloWorld();

                 obj.x=5;

         }

}

12.静态变量和静态方法都是在类装载的时候存在于内存中的.

非静态的方法和成员只有通过NEW创建对象后才存在和可以调用...才可以使用对象的属性和方法,,,但是对于STATIC修钸的变量的方法却一直在内存中存在,并且所有的该类的对象都只共享这一个..不需要先定义对象就可以直接使用.   用在需要统计的变量中(比如统计一个类创了多少对象,这时定义一个表态变量,在构函中对这个表态变量进行加加).,静态方法使用在不需要创建对象就可以访问的时候,可以在静态和非静态方法中直接访问它,也可以通过类名和对象来访问.

静态方法访问非静态方法时要先创建对象(因为非静态方法事先不存在,要创建对象后才有内存单元),静态方法中也不能以任何形式引用THIS或SUPER关键字(因为静态方法中不存在对象).

    静态成员的提出是为了解决数据共享的问题。实现共享有许多方法，如：设置全局性的变量或对象是一种方法。但是，全局变量或对象是有局限性的。这一章里，我们主要讲述类的静态成员来实现数据的共享。

静态数据成员

    在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。

    使用静态数据成员可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

要用到某一类时才加载该类,,加载时会先执行该类的静态代码块,static{   },,而且只执行一次.

设计模式::编程中的成功的方案和经验.

单态设计模式::内存中只能存在一个类的实例对象..这样的话,类外面就不能创建它的对象,所以就应该让这个类的构函成为私有的,这样就只能在类中创建该对象了，为了让外面能访问到该类的对象同时又不能先在外面创建对象，所以就应该提供一个静态的方法来获取该类的对象，同时类中创建的对象也必须为静态的。其作用::: 一个Runtime对象代表一个Java虚拟机，那么在一个程序中就不能产生多个Runtime对象，因为当前运行的Java程序只属于一个 虚拟机

  public class HelloWorld

{

         static HelloWorld objref=new HelloWorld();//类内部创建 个对象的引用(实例).

                                                                                                         //而且只能是静态的.

         private HelloWorld()

         {

         }

         static public HelloWorld getinstance()

         {

                 return objref;

         }

}

class test

{

  public static void main(String[] args)

  {

         HelloWorld obj1=HelloWorld.getinstance();

         HelloWorld obj2=HelloWorld.getinstance();

         System.out.println(obj1==obj2);//print TRUE/FALSE

  }

}

13．内部类b可以访问包含它的类a的成员（包括私有成员）。但是b却不能被包含它的类a所访问。当内部类前有STATIC时，它相当于外部类了，就不能直接访问包含它的类的方法了。

    Class a 

   {   int size;

     class b.

     {

           int size;

           public void geta(int size)

             {

                                  size;//引用的是geta(int size) 的                                             this.size;//引用的是B中的

                          a.size;//引用的是A中的

}

}

内部类的第一个好处就体现出来了——隐藏你不想让别人知道的操作，也即封装性。

在内部类Content的方法value()计算价值时把它乘上。我们发现，value()可以访问valueRate，这也是内部类的第二个好处——一个内部类对象可以访问创建它的外部类对象的内容，甚至包括私有变量！这是一个非常有用的特性，为我们在设计时提供了更多的思路和捷径。要想实现这个功能，内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时，隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象，同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。

内部类的真正作用是，java中的内部类和接口加在一起，可以的解决常被C++程序员抱怨java中存在的一个问题——没有多继承。实际上，C++的多继承设计起来很复杂，而java通过内部类加上接口，可以很好的实现多继承的效果。

有人会问，如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：

outerClass.this

有了它，我们就不怕这种屏蔽的情况了。

14.          1) 在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。(F:/study/java笔记/初识Java内部类 - 放飞技术网.htm)

2). 那么还有没有别的方法呢？当然有，其语法格式如下：

outerObject=new outerClass(Constructor Parameters); outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

注意在创建非静态内部类对象时，一定要先创建起相应的外部类对象。至于原因，也就引出了我们下一个话题——

15.内部类的定义位置::可以在类中定义也可以在方法中定义,,如果在方法中定义的话,它可以访问外部类中的成员变量.它只能访问方法体中的FINAL型变量..

15.          如果一个类没有定义任何构造函数，则编译器将生成一个缺省的构造函数，该构造函数的访问修改符和类的

访问修改符相同，例如：

class test将生成test()构造函数

public class test将生成public test()构造函数。

对于一个完整的程序，他们在内存中的分布情况如下图：
程序内存空间

(code area)
代码区

(data area)
全局数据区

(heap area)
堆区

(stack area)
栈区

一般程序的由malloc,realloc产生的动态数据存放在堆区，程序的局部数据即各个函数内部的数据存放在栈区，局部数据对象一般会随着函数的退出而释放空间，对于static数据即使是函数内部的对象则存放在全局数据区，全局数据区的数据并不会因为函数的退出就将空间释放。

16.          成员访问控制：

	private	Default（包际访问）	protected	public
同一个类
同一个包中类
子类
不在同一个包中类

17.