java面向对象

 

    对象属于引用类型，栈中保存指向堆类属性等的引用，即指针。要时刻联想到内存。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　--写在最前面的

   

    关键词

　　　　　　构造方法私有化、匿名对象、String、引用传递、this、static、内部类、代码块、对象数组...

    

    匿名对象

　　　　

     　　new Person("张三",29);   //只在堆存储区存在，栈里面没有对象引用

     　　"hello world"    //就是一个匿名对象

 

    String

　　　　　　String的比较

　　　　　　　　　　 

　　　　　　　　　　　　 String s1 = "weicong";                  //匿名对象，堆
        　　　　　　　　String s2 = new String("weicong");      //堆，栈里面是引用
        　　　　　　　　String s3 = s2;                         //引用赋值，存的是同一个地址
        
        　　　　　　　　System.out.println(s1==s2);             //false       比较的是地址
        　　　　　　　　System.out.println(s1==s3);　　　　　　　 //false
        　　　　　　　　System.out.println(s2==s3); 　　　　　　　//true
        
        　　　　　　　　System.out.println(s1.equals(s3));      //比较的是堆里面的内容
        　　　　　　　　System.out.println(s1.equals(s2));
        　　　　　　　　System.out.println(s2.equals(s3));

 

 　　      　　两种实例方式

　　　　　　　　　　　　

　　　　　　　　　　　　String a = "111";              //指向同一个堆内存
　　　　　　　　　　　　String b = "111";

　　　　　　　　　　　　String c = new String("222");   //会开辟两个新的堆内存

                       

 

　　　　　　字符串的内容不可改变

　　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　String str = "111";
　　　　　　　　　　　　　　　　str = str + "222";
　　　　　　　　　　　　　　　　System.out.println(str);     //打印出来是111222
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//但实际堆内存是不变的,会增加一个"222",然后再增加一个"111222"
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　  //只是str引用的地址变成了新的地址，原来的还在
                    
                                                        //所以，不要频繁的写诸如   str=str+"2121"之类的代码

　　　　　　　　　　　　　　　

　　　　　　一些常用的方法

　　　　　　　　　　　　　　字符串与字符数组、字节数组互相转换，

　　　　　　　　　　　　　　length  length()

　　　　　　　　　　　　　　还有一些截取，分割什么的.....

 

　　　　　　引用传递

　　　　　　　　　　　　　　

               　　　　
  
                   public class Yinyong {
   　　　　　　　　　　　　 public static void main(String [] args){
        
        　　　　　　　　　　　　　　String str1 = "111";
        　　　　　　　　　　　　　　System.out.println(str1);         //111
        
        　　　　　　　　　　　　　　Yinyong.fun(str1);
        　　　　　　　　　　　　　　System.out.println(str1);         //111
        
   　　　　　　　　　　　　　　 }
    
    　　　　　　　　　　　　public static void fun(String str2){
        
        　　　　　　　　　　　　　　str2 = "222";
    　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　}

                      //例子2
　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　　public class Yinyong {
　　　　　　　　　　　　　　　　　　　　public static void main(String [] args){

　　　　　　　　　　　　　　　　　　　　　　　　　　A a = new A();
　　　　　　　　　　　　　　　　　　　　　　　　　　a.str = "111";
　　　　　　　　　　　　　　　　　　　　　　　　　　System.out.println(a.str);           //111

　　　　　　　　　　　　　　　　　　　　　　　　　　Yinyong.fun(a);                      //改变的也许是str里面存的地址
　　　　　　　　　　　　　　　　　　　　　　　　　　System.out.println(a.str);           //222

　　　　　　　　　　　　　　　　　　　　　　　　　　}

　　　　　　　　　　　　　　　　　　　　　　　　　　public static void fun(A b){

　　　　　　　　　　　　　　　　　　　　　　　　　　b.str = "222";          
　　　　　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　　　　}
　　　　　　　　　　　　　　　　　　　　class A{

　　　　　　　　　　　　　　　　　　　　　　　　　　String str = "000";              //我觉得str其实是"000"的地址，二级指针的感觉

　　　　　　　　　　　　　　　　　　　　　　　　}

 

 

 　　　　　　this

　　　　　　　　this.name      

　　　　　　　　this();         //调用构造函数

　　　　　　　　this;           //表示当前对象

 

   　　　　　 static

　　　　　　　　static修饰的变量，叫全局变量或者静态变量

　　　　　　　　

public class A{

         Static String country = "xx";
         String name ;
         String age; 


          public static void main(){

              A p1 = new A();
              A p2 = new A();
              A p3 = new A();
     }  
}

                       

　　　　　　　　　全局变量具有共享性，牵一发而动全身。

　　　　　　　　　static修饰的方法和属性，都叫类方法或者类属性，可以被类直接调用而不实例化     Person.name;

　　　　　　　　　类方法不能调用任何包括static的内容的，这是因为其他方法或者属性实在实例化才能调用的，而staitic修饰的可以被类直接调用。反过来非static可以调用类属性或者方法

　　　　　　　　　static的应用，可以用来计数之类的。因为每一次实例化调用构造函数，所以可以用来计数对象的个数

　　　　　　　　　理解  public static void main(String args[])

　　　　

　　　　　　代码块

　　　　　　　　　普通代码块，构造代码块，静态代码块，同步代码块

　　　　　　　　　普通

　　　　　　　　　　　　　　就是一般的代码块

　　　　　　　　　构造

　　　　　　　　　　　　　　

　　　　　　　　　　　　　　public class Daimakuai {

   　　　　　　　　　　　　 {
        　　　　　　　　　　　　　　System.out.println("--------------");
        
    　　　　　　　　　　　　}
    　　　　　　　　　　　　　　　　Daimakuai(){
        
        　　　　　　　　　　　　　　　　　　System.out.println("11111111111");
        
    　　　　　　　　　　　　　　　　　　　　　　　　}
   　　　　　　　　　　　　　　　　 public static void main(String[] args) {
        
        　　　　　　　　　　　　　　　　　　　　new Daimakuai();
        　　　　　　　　　　　　　　　　　　　　new Daimakuai();
        　　　　　　　　　　　　　　　　　　　　new Daimakuai();                  //-------------1111111111111
    　　　　　　　　　　　　　　　　　　}　　　　　　　　　　　　　　　　　　　　　　　 //说明构造代码块优先于构造函数执行

　　　　　　　　　　　　}

　　　　　　　　　　静态

　　　　　　　　　　　　　　　　主方法的静态代码块优先于主方法执行，反正静态代码块优先于所处位置的其他地方代码先执行