java——面向对象

对象的概念

 

1. 什么是对象（具体的定义状态（属性）和行为（方法）的一个实体）

一切客观存在的事物都是对象

2.对象的组成

属性 有什么（描述对象） 对象的属性也可以是对象

方法 能做什么（自己使用 别人使用）

3.      计算机世界中的对象（连续的存储空间）

类的概念

1. 类是什么

具有相同行为和状态的对象的集合

a)        类是对大量共性的抽象

b)       类是客观事物在人脑中的主观反映

c)        类是创建对象的模板

 

先有类，后有对象

class Student{

        String name;//属性、实例变量、成员变量

        int age;

}

2. 定义类、创建对象

a)        创建对象 new Student();

b)       定义一个变量存储创建的对象

Student s;

s = new Stuent();

可写在一起

Student s = new Stuent();

 

基本类型 8种

对象类型（引用）：数组、对象、接口

3. 实例变量（类中的变量） 属于对象

a)        访问 .

b)       属性初始化

class Student{

       String name = “suns”;

       int age;

}

4. 实例变量（类）与局部变量（方法）的区别

局部变量

先赋值后使用

作用范围（从定义的代码块开始到定义的代码块结束）

命名不可冲突（同一作用范围内）

实例变量

可以不赋值就使用

a)        实例变量存在默认值（各种各样的0）

b)       实例变量至少在本类的范围内有效

c)        实例变量可以和局部变量命名冲突，局部变量优先使用

 

方法

 

方法声明、方法实现

1. 格式

修饰符 返回值类型 方法名(参数1,参数2) [异常]{

               方法体

}

 

方法的重载（Overloading）

1. 方法重载（Overloading） 同一个类中方法名相同、参数不同

2. 源码参考

 

class A{

        //参数个数不同

        void m(){}

        void m(int a){}

        void m(int a,int b){}

        //参数类型不同

        void m(String s){}

        //参数类型相同但排列不同

        void m(int a,String s){}

        void m(String s,int a){}

        //形参名字不同 不算重载

        void m(int a){}

        void m(int b){}

}

3. 方法重载的意义

对方法的调用者屏蔽因方法参数不同所造成的差异

 

构造方法

 

特殊性：定义语法 作用

1.构造方法的概念

       publicStudent(){

 

}

a)        没有返回值类型（和没有返回值void不同）

b)       方法名同类名一致

c)        用在对象的创建 构造对象

2.      构造方法的重载

3. 构造方法的特点

a)        构造方法不能手工调用，被JVM自动调用

Student s = new Student();//告诉虚拟机

s.Student();

b)       构造方法在对象构造时，被自动调用一次，而且只会被调用一次

                       i.             分配空间

                     ii.             初始化属性

                   iii.             调用构造方法

c)        构造方法没有返回值

d)       如果一个类中没有定义构造方法，系统默认提供一个公开的、无参的空构造方法

4. 构造方法的使用场景

构造方法经常用于给实例变量赋值

 

对象与引用

 

1.引用概念

Student s;

s = new Student();

2. 引用存储的是对象内存空间的首地址

s.print();//遥控器与电视机的关系

s指向首地址

3. 程序中的值传递

简单类型存储值（在内存中）

对象类型存储地址

1. //TestValue1.java   
2. package chp6.ex08;  
3.   
4. /** 
5.  *  
6.  * 说明：本程序演示了值传递 结果为10 基本类型 内存中存的是值 
7.  */  
8. public class TestValue1 {  
9.   public static void main(String args[]){  
10.       int a = 10;  
11.       int b = a;  
12.       b++;  
13.       System.out.println(a);  
14.   }  
15. }  
16.   
17. //答案：10  
18.   
19. //TestValue2.java   
20. package chp6.ex09;  
21.   
22. /** 
23.  *  
24.  * 说明：本程序演示了值传递  结果为21 对象类型 内存中存储的是地址 
25.  */  
26. public class TestValue2 {  
27.   public static void main(String args[]){  
28.      Student s1 = new Student();  
29.      Student s2 = s1;//s2和s1指向的是同一地址  
30.      s2.age = 21;  
31.      System.out.println(s1.age);  
32.   }  
33. }  
34. class Student{  
35.   int age = 20;  
36. }  
37.   
38. //答案：21  
39.   
40. //TestValue3.java   
41. package chp6.ex10;  
42.   
43. /** 
44.  *  
45.  * 说明：本程序演示了方法中的值传递 结果为10 基本类型 内存中存的是值 
46.  */  
47. public class TestValue3 {  
48.     public static void main(String args[]){  
49.         int a = 10;  
50.         m1(a);  
51.         System.out.println(a);  
52.             
53.      }  
54.       
55.     public static void m1(int a){  
56.         a ++;  
57.     }  
58. }  
59.   
60. //答案：10  
61.   
62. //TestValue4.java  
63. package chp6.ex11;  
64.   
65. /** 
66.  *  
67.  * 说明：本程序演示了的方法中的值传递  结果为21 对象类型 内存中存储的是地址 
68.  */  
69. public class TestValue4 {  
70.    public static void main(String args[]){  
71.       Student s = new Student();  
72.       m2(s);  
73.       System.out.println(s.age);  
74.         
75.    }  
76.    public static void m2(Student stu){   
77.        stu.age++;  
78.    }  
79. }  
80. class Student{  
81.   int age = 20;  
82. }  
83.   
84. //答案：21   

//TestValue1.java 
package chp6.ex08;

/**
 * 
 * 说明：本程序演示了值传递 结果为10 基本类型 内存中存的是值
 */
public class TestValue1 {
  public static void main(String args[]){
	  int a = 10;
	  int b = a;
	  b++;
	  System.out.println(a);
  }
}

//答案：10

//TestValue2.java 
package chp6.ex09;

/**
 * 
 * 说明：本程序演示了值传递  结果为21 对象类型 内存中存储的是地址
 */
public class TestValue2 {
  public static void main(String args[]){
     Student s1 = new Student();
     Student s2 = s1;//s2和s1指向的是同一地址
     s2.age = 21;
     System.out.println(s1.age);
  }
}
class Student{
  int age = 20;
}

//答案：21

//TestValue3.java 
package chp6.ex10;

/**
 * 
 * 说明：本程序演示了方法中的值传递 结果为10 基本类型 内存中存的是值
 */
public class TestValue3 {
	public static void main(String args[]){
		int a = 10;
		m1(a);
		System.out.println(a);
		  
	 }
	
	public static void m1(int a){
		a ++;
	}
}

//答案：10

//TestValue4.java
package chp6.ex11;

/**
 * 
 * 说明：本程序演示了的方法中的值传递  结果为21 对象类型 内存中存储的是地址
 */
public class TestValue4 {
   public static void main(String args[]){
	  Student s = new Student();
	  m2(s);
	  System.out.println(s.age);
	  
   }
   public static void m2(Student stu){ 
	   stu.age++;
   }
}
class Student{
  int age = 20;
}

//答案：21 

 

this关键字

 

1. this关键字的概念

this是一种特殊的引用，指向当前对象

2. this的作用

a)        如果方法局部变量与实例变量命名冲突时，可以通过this属性的方式区分实例变量和局部变量

b)       如果发生一个构造方法中需要调用另一个构造方法，可以通过this()的方法调用，但this()必须书写在第一行

 

 

String类

 

1. 创建一个字符串对象

String s = “suns”;

String s = newString(“suns”);

2.      字符串值的判断equals方法

String s1 = newString(“suns”);

String s2 = newString(“suns”);

System.out.println(s1== s2);//false ==判断引用

System.out.println(s1.equals(s2));//true equas判断内容

3.      串池（””创建的字符串独立存储在内存的串池空间中）

String s1 = “suns”;

String s2 = “suns”

System.out.println(s1== s2);//true

4.      String类中的常用方法

booleanequals();

char charAt(intpos);

int length();//方法 数组length为属性

String[]split();

booleanstartWith(String s);

trim();

StringsubString(int begin,int end);

//”suns”.subString(0,2);su

5.      字符串的连接

//不好过多侵占内存空间

String s1 = “sun”;

String s2 = “shuai”

String s2 = s1 +s2;

 

//推荐使用不会开辟新空间

StringBuffer sb= new StringBuffer();

sb.append(“sun”);

sb.append(“shuai);

System.out.println(sb);

装载于：http://blog.csdn.net/justdb/article/details/7849931