java——面向对象

  • 来源:csdn博客

对象的概念

 

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