码迷,mamicode.com
首页 > 编程语言 > 详细

Java入门——(2)面对对象(上)

时间:2017-06-27 23:23:05      阅读:253      评论:0      收藏:0      [点我收藏+]

标签:特征   code   针对   java入门   检查   long   核心   单例   其他   

 
关键词:面对对象、类、、构造方法、this、static、内部类
 
一、面对对象的概念:把解决的问题安装一定规则划分为多个独立的对象,然后通过调用对象的方法来解决问题。其特点可概括为封装性、继承性、多态性。
    1、封装性:面对对象的核心,将对象的属性和行为封装起来,不需要让外界知道具体实现细节,这就是封装思想。
    2、继承性:主要描述的是类与类之间的关系,通过继承,可以在无需重新编写原有类的情况下,对原有类的功能进行扩展。
    3、多态性:是在程序中允许出现重名现象,它指在一个类中定义的属性和方法被其他类继承后,他们可以具有不同的数据类型或表现出不同的行为,这使得同一个属性和方法在不同的类中具有不同的语义。
二、类与对象
     1、类是对象的抽象,它用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法,其中成员变量用于描述对象的特征,也称作属性,成员方法用于描述对象的行为,可简称方法。
         如何创建类:
1 class Person{
2      //定义int 类型的变量
3       int age;
4      //定义speak()方法
5       void speak (){
6             System.out.println(“***”)
7       }
8 } //Person 类名,age 是成员变量,speak()成员方法
2、对象的创建与使用:
     创建:类名 对象名= new 类名();//实例对象
     使用: 对象引用.对象成员;
     实例化对象时,Java虚拟机会自动为成员变量进行初始化,针对不同类型的成员变量,赋予不同的初始值。
表:成员变量的初始值
成员变量类 初始值 成员变量类 初始值
    byte   0 double 0.0D
short 0 char 空字符,‘\u0000‘
int 0 boolean false
long  0L 引用数据类型 null
float 0.0F    
在Java中,null是一种特殊的常量,当一个变量的值为null时,则表示该变量不指向任何一个对象,变成垃圾被回收。 
 
3、所谓的类的封装是指定义一个类时,将类中的属性私有化,即利用private 关键字来修饰,私有属性只能在它所在类中被访问。为了能让外界访问私有属性,需要提供一些使用public 修饰的公用方法,其中包括用于获得属性值得getXXX()方法和设置属性值得setXXX()方法。
 
 1 class Student{
 2     private String name;    //将name属性私有化
 3     private int age;        //将age属性私有化
 4     //下面是公有的getXXX()和setXXX()方法
 5     public String getName (){
 6         return name;
 7     }
 8     public void setName(String stuName){
 9         name = stuName ;
10     }
11     public int getAge (){
12         return age ;
13     }
14     public void setAge(int stuAge){
15         //下面是对传入的参数进行检查
16         if(stuAge<=0){
17             System.out.println("年龄不合法");
18         }else {
19             age = stuAge ;        //对属性赋值
20         }
21     }
22     public void introduce(){
23         System.out.println("大家好,我叫"+name+",我今年"+age+"岁!");
24     }
25 }
26 public class Example01{
27     public static void main(String[] args){
28         Student stu  = new Student();
29         stu.setAge(-30);
30         stu.setName("李芳");
31         stu.introduce();
32     }
33 }
 
三、构造方法
1、构造方法:构造方法是类中一个特殊成员,它会在实例化对象时被自动调用。
2、构造方法的特点:
 ①方法名与类名相同;

 ②在方法名前面没有返回值类型的声明;

 ③在方法中不能使用return语句返回一个值;

 1 class Person{
 2       //构造方法
 3      public Person(){
 4           //无参构造方法
 5       }
 6      public Person(int age){
 7           age = a;   //有参构造方法
 8      }
 9      public void speak(){
10           System.out.println(“I am” +age+”years old !");
11      }
12 }
13 public  class Example{
14      public  static void main (String [] args){
15          Person p = new Person(20);  //实例化Person对象
16          p.speak();
17      }
18 }

 

3、构造方法的重载:与普通方法一样,方法名相同,只需要参数类型或参数个数不同即可。
     一般情况下,构造方法通常会使用public来修饰。
 
 
四、this 关键字
1、this关键字三种常用方法:

①通过this关键字可以明确地访问一个类的成员变量,解决与局部变量名称冲突问题。

 1 class Person{
 2      int age ;
 3      public Person(int age){
 4           this.age = age ;   //访问成员变量
 5      }
 6      public int getAge(){
 7          return this .age;
 8     }
 9  }

②通过this关键字调用成员方法。

③构造方法是在实例化对象时被Java虚拟机自动调用的,在程序中不能像调用其他方法一样去调用构造方法,但可以在一个构造方法中使用“this(【参数1,参数2……】)”的形式来调用其他的构造方法。

注意点:

①只能在构造方法中使用this 调用其他的构造方法,不能在成员方法中使用。

②在构造方法中,使用this 调用构造方法的语句必须位于第一行,且只能出现一次。

③不能在一个类的两个构造方法中使用this互相调用。

 
五、static关键字
1、使用static关键字来修饰成员变量,该变量被作静态变量。静态变量被所有实例共享,可以使用“类名.变量”的形式来访问。
    注意:static关键字只能用于修饰成员变量,不能用于修饰局部变量。
2、静态方法:在类中定义的方法前加上static关键字,可在不创建对象的情况下调用某方法。可使用“类名.方法名”的形式访问。
     注意:在一个静态方法中只能访问static修饰的成员,静态方法在被调用时可以创建任何对象。
3、静态代码块:用static关键字修饰的代码块称为静态代码块,当类被加载时,静态代码块会被执行,由于类只加载异常,因此静态代码块只能执行一次。
 
4、单例模式:
 1 class Single{
 2      private static Single INSTANCE = new Single();
 3      private Single(){}
 4      public static Single getInstance(){  
 5          return INSTANCE ; 
 6        }
 7 }
 8 //上面单例又可写成以下形式
 9 class Single{
10      private Single(){}
11      public static final Single INSTANCE = new Single();
/*变量名INSTANCE的前面有三个修饰符,其中,public的作用是允许外部直接访问该变量,static 的作用是 让外部可以使用
“类名.变量名“的方式来访问变量,final的作用是禁止外部对该变量进行修改。*/ 12 } 13 14 class Example { 15 public static void main(String[] args){ 16 Single s = Single.getInstance(); // getInstance()方法是获得Single类实例对象的唯一途径,Single 类是一个单例的类 17 } 18 }
被关键字final修饰的变量为常量,其值不可变。
 
六、内部类:根据内部类的位置、修饰符和定义的方式可分为成员内部类、静态内部类、方法内部类。
1、创建内部类对象的具体语法格式:
    外部类名.内部类名 变量名 = new 外部类名().new 内部类();
 1 class Outer{
 2     private int num = 4;              //定义类的成员变量
 3     //下面的代码定义了一个成员方法,方法中访问内部类
 4     public void test(){
 5         Inner inner = new Inner();
 6         inner.show();
 7     }
 8     //下面的代码定义了一个成员内部类
 9     class Inner{
10         void show(){
11             //在成员内部类的方法中访问外部类的成员变量
12             System.out.println("num = "+num);
13         }
14     }
15 }
16 public class Example16 {
17     public static void main(String[] args){
18         Outer outer = new Outer();               //创建外部类对象
19         outer.test();                                 //调用test()方法
20     }
21 }
22 //直接创建内部类对象示例
23 public class Example16 {
24     public static void main(String[] args){
25         Outer.Inner inner = new Outer().Inner() ;               //创建内部类对象
26         inner.show();                                 //调用show()方法
27     }
28 }
29 //当内部类被声明为私有,外界将无法访问。
2、创建静态内部类对象的具体语法格式:
     外部类名.内部类名 变量名 = new 外部类名.内部类名();
 1 class Outer{
 2     private static int num = 6;              //定义类的成员变量
 3     //下面的代码定义了一个静态内部类
 4     static class Inner{
 5         void show(){
 6             System.out.println("num = "+num);
 7         }
 8     }
 9 }
10 public class Example16 {
11     public static void main(String[] args){
12         Out.Inner inner = new Out.Inner();             //创建内部类对象
13             inner.show();                                 //调用内部类的方法
14     }
15 }

     注意:①在静态内部类中只能访问外部类的静态成员。

              ②在静态内部类中可以定义静态成员,而在非静态的内部类中不允许定义静态的成员。
 
3、方法内部类:是指在成员方法中定义的类,它只能在当前方法中被使用。方法内部类可以访问外部类的成员变量。

Java入门——(2)面对对象(上)

标签:特征   code   针对   java入门   检查   long   核心   单例   其他   

原文地址:http://www.cnblogs.com/gdwkong/p/7087324.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!