对象与引用

• java语言中除基本类型之外的变量类型都称之为引用类型。

• java中的对象是通过引用对其操作的.

例如 我们有一个自定义为Car(汽车类)

class Car{

String color;

String name;

String model;

}

Car bm = new Car();

通常把这条语句的动作称之为创建一个对象,其实，它包含了三个动作。

1)右边的“new Car()”，是以Car类为模板，调用Car类的构造函数,在堆空间里创建一个Car类对象。

2)左边的Car bm是创建了一个引用变量，就是可以用来指向Car对象的引用

3)=操作符使对象引用指向刚才所创建的对象，也就是将对象的地址赋给引用变量bm

值传递和引用传递

• 值传递：方法调用时，实际参数把自己的值传递给形式参数，形式参数只是用实际参数的值来初始化自己的存储单元内容，两个存储单元是不同的，所以形式参数的值改变并不会影响实际参数的值

public class Demo {    
     private int a;    
    /*          
    基本类型值传递                    
    */    
    public static void main(String[] args) {        
        Demo d = new Demo();        
        int a =10;       
        d.test(a);        
        System.out.println(a);    
    }    
    /*    
    形参b    
    用实参a的值,直接对b进行了赋值,在内存中有两个独立的存储空间 a,b    
    */    
    public void test(int b) {        
        b =20;//b的值发生改变 不会影响到a    
    }}

• 引用传递：也就是传地址，方法调用时，实际参数就是对象，这个时候实参和形参指向的是同一个地址，所以这个方法执行时对形参的改变会影响到实参

public class Demo {    
    /*      
      引用类型 在传递时,传的是对象的地址            
      */    
      public static void main(String[] args) {       
      Demo d = new Demo();      
      Person zs = new Person("张三",20);      
      d.test(zs);//只是把对象的地址传给了 p                                         System.out.println(zs.name);//李四
      }    
      /*    
      */    
      public void test(Person p) {
      //p和zs指向的是同一个对象           
      p.name = "李四";    }

总结：基本类型值传递是该数据的本身，而引用类型的传递是对对象的引用，传的是地址而不是对象的本身。

this关键字

• this关键字代表当前对象

• 使用this关键字引用成员变量

• 使用this关键字引用成员方法

在一个类中方法或者构造方法内部，可以用“this.成员变量名”这样的格式来引用成员变量名，常常可以用来区分成员变量和局部变量

public class Demo{

private int a;

public Demo(int a){

this.a = a;

}

public int getA(){

return a;

}

public void setA(int a){

this.a = a;

}

}

static关键字

• static被成为静态，可以用来修饰类的属性，方法，代码块，内部类。

  • 随着类的加载而加载

  • 优先于对象的存在

  • 修饰的成员，被所有对象共享

  • 可不创建对象，直接被类调用

    /*    
     static 静态 修饰属性,方法,代码块,内部类(后面讲)           
       类变量,和类一样只有一份       
      被static修饰的内容，随着类的加载而加载,优于对象存在,被所有对象共享,可以通过类名直接调用       
 */
     public class Chinese {    
       String name;//name属性不建议修饰为static,在内存中只有一份,而name每个对象都不一样    
         int age;    
         static String country = "中国";//常量一般修饰为static        
         /*           
         static修饰方法,类方法,静态方法不能使用非静态的成员变量,静态资源随着类先加载,                         
         非静态的随着对象的创建而加载        
         */    
         public static void test(){        
             //System.out.println(name);    
         }     
         /*          
         非静态方法可以使用静态变量,非静态方法必须通过对象来调用,对象创建之前先加载类        */    
         public void test1(){       
             System.out.println(country);    
         }}
​
public class Test {
​
    public static void main(String[] args) {
        Chinese zs = new Chinese();
                zs.name = "张三";
                zs.age = 20;
        Chinese ls = new Chinese();
        ls.name = "李四";
        ls.age = 20;
​
        Chinese.country = "china";
        System.out.println(zs.name);
        System.out.println(ls.name);
        System.out.println(zs.country);
        System.out.println(ls.country);
​
        Chinese.test();//静态方法,静态变量 建议使用类名调用
    }
}

代码块

   public class Demo {    
     String name;    
     static String country = "中国";    
     public Demo() {        
     System.out.println("无参构造");    
     }    
     /*      
     代码块：类似一个没有名字的方法.      
     代码块：
     实例代码块  在创建对象之后执行,调用构造方法之前执行,每创建一次对象,执行一次             
     静态代码块  在类加载时候执行,只执行一次,多个静态按照先后顺序            
     类什么时候加载?             
     main方法在哪个类中执行,这个类加载的.             
     创建某个类的对象，             
     调用某个类中的静态属性,方法         
     */ 
     {        
     System.out.println("实例代码块");    
     }   
     static {        
     System.out.println("静态代码块2");    
     }   
     static {       
     System.out.println("静态代码块1");    
     }
     }
​
public class TestDemo {
​
    public static void main(String[] args) {
        new Demo();
        new Demo();
​
        //System.out.println(Demo.country);
        //System.out.println(Demo.country);
    }
}

包

包：为了更好地组织类,java提供了包机制，用于区别类名的命名空间(是类路径中的一部分 地址)。       
避免类重名      
按功能管理(目前按日期管理)          
GUI(窗口)          
数据访问层          
工具类         
包的命名规则：包名都小写             
项目类型：com(商业) org(组织) edu gov             
公司名称：oracle sun huawei            
项目名称：oa,erp,cms             
功能模块：窗口/视图层  数据访问层 服务层  工具类               
细分子模块

访问权限修饰符

java有四种访问权限修饰符，由大到小依次是public，protected，default，priva

/*   
访问权限修饰符：用来修饰类,成员变量,成员方法,内部类,控制对齐访问的权限   
访问权限和包是密切相关的   
public     公共的    类,成员变量,方法,内部类    在任何类中都可以访问   
protected  保护的      成员变量,方法,内部类   
(default)  默认的(无)  类,成员变量,方法,内部类   
private    私有的       成员变量,方法,内部类   
*/
public class Demo1 {       
public String pubname;       
protected  String proname;      
String name;   
private  String priname;  
​
public void pubtest(){       }  
​
protected  void protect(){       }    
​
void test(){       }      
​
private void pritest(){       }   
​
​
public static void main(String[] args) {       
Demo1 demo1 = new Demo1();      
System.out.println(demo1.pubname);        System.out.println(demo1.proname);        System.out.println(demo1.name);        System.out.println(demo1.priname);//在本类中都可以访问到      
}}

封装

/*   
封装：将类的某些信息隐藏起来(用访问权限修饰符来实现),不让在外部直接对其访问,        可以通过一个特定的方法来对隐藏信息进行访问,便于控制        
设计模式：解决某一类问题的解决方案(模式)        
单例模式-->让一个类在一个程序,只能创建一个对象
*/
public class Dog {   
//隐藏类的属性    
private String name; 
    
public Dog(){    }    
        public Dog(String name) {        
                  if (name!=null){            
                     this.name = name;        
                 }    
               }    
private void eat(){    }   
//提供特定的方法,对隐藏成员进行访问    
public void setName(String name){  
if(name!=null){            
this.name = name;        
}    }  
public String getName(){        
return this.name;   
}}
​
public class TestDog {
​
    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        //dog.name = "";//直接访问类的成员
​
        Dog dog1 = new Dog();
        dog1.setName("小黑");
​
        System.out.println(dog1.getName());
        System.out.println(dog.getName());
    }
}