java 基础之面向对象一-摩杜云开发者社区

1、程序分为面向过程和面向对象

1）面向过程：
分析问题所需要的步骤，然后用函数把这些步骤一一实现，使用的时候一个一个调用。

2）面向对象：
把解决的问题按照一定的规则，划分为多个独立的对象，通过调用对象的方法来解决问题。

面向对象的主要特点分为封装性，集成性，多态性。

2、类的封装

1）类中private 修饰的变量值只能够在类的内部访问
外部要想访问，可以通过public 的方法

class Student {
    private String name;
    public void setName(String strname) {
        name = strname;
    }
    public void getNmane() {
     return name;
    }
    public void inTroduce() {
    Log.v(TAG,"name" + name);
    }
}

public class Test {
    public static void main(String[] args) {
    Student student = new Student();
    student.setNmae("LM");
    String str = student.getNamne();
    }
}

2）构造方法
（1）方法名和类的名字相同
（2）在方法名前没有返回值类型的声明
（3）在方法中不能使用return 语句返回一个值

实例化对象的时候会自动调用构造方法。

class Persion{
    String name;
    int age;
    //定义一个参数的构造方法
    public Persion(String con_name) {
    name = con_name; //为name 属性值赋值
    }
    public Persion(String con_name, int con_age) {
    name = con_name;
    age = con_name;
    }
    public void speak() {
    Log.v(TAG,"name:"+name+"age:"+age)
    }
}

public class Test{
    public static void main(String[] args) {
    Persion p1 = new Persion("L1");
    Persion p1 = new Persion("L2",26);
    p1.speak();
    p2.speak();
    }
}

其中一个打印：
name: L1 age:0
name:L2 age:26

3、this关键字

1）在类中，通过this 可以明确的访问一个类的成员变量，解决与局部变量名称的冲突

class Person {
int age;
public Persion(int age){
    this.age = age;//赋值给类的属性值
    }
public int getAge() {
    return this.age;//返回属性值
    }
}

2）在类中，用this 关键字调用成员方法

class Person {
    public void openMouth() {
        //do something
        }
    public void speak() {
    this.openMouth();
    }
}

3)在类中，构造方法调用构造方法

class Person {
    public Person() {
    Log.v(TAG,"无参数构造方法");
    }
    public Person(String name) {
    this();//调用无参数构造方法
    Log.v(TAG,"有参数构造方法");
    }
}

public class Test {
    public static void main(String[] args) {
        Person p1 = new Person("LM");
    }
}

我们可以看到调用了两个构造方法：
无参数构造方法
有参数构造方法

使用this调用构造方法时应该注意：
（1）只能在构造方法中使用this 调用其他的构造方法，不能在成员方法中使用。
（2）在构造方法中，使用this().要放在第一行且只能出现一次。

public Person() {
String name = "LM";
this (name);
}

这就是错的。
（3）不能在一个类的两个构造方法中使用this()相互调用。

4、static 关键字

1）修饰成员变量的时候
（1）static 关键字只能够修饰类的成员变量，不能修饰局部变量。
（2）可以通过类名.变量名的形式访问。
（3）被所有的实例化对象共享对象.变量名

2）修饰静态方法的时候
可以实现类名.方法名来实现访问，不需要先实例化对象。

class Person {
    public static void sayHello() {
        Log.v(TAG,"hello");
    }
}

class Test {
    public static void main(String[] args) {
        Person.sayHello();//类名直接调用静态方法
    }
}

注意：一个静态方法只能是访问被static修饰的成员。

3）静态代码快
（1）被一个大括号包围起来的代码，是代码快。
（2）static 修饰一下就是静态代码快。
（3）类被加载时，静态代码快会被执行。
（4）由于类只被加载一次没所以静态代码快也只执行一次。

在程序中常使用静态代码块来初始化成员变量

class Person {
static String  country;
static {
country = "china";
Log.v(TAG,"test static country");
}
}

class Test {
    static {
    Log.v(TAG,"test static");
}
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();
    }
}

运行结果：
test static country
test static

两个static 修饰的代码块都实现了运算。

4、单例模式

1）是指在设计一个类时保证整个程序在运行期间都只存在一个实例对象，就像天上有一个太阳一样。

class Single {
//自己创建一个对象
    private static Single INSTANCE = new Single();
    private Single() {}; //私有化结构方法
    public static Single getInstance() {  //提供返回该对象的静态方法
    return INSTANCE;
    }
}

class Test {
    public static void main(String[] args) {
        Single s1 = new Single();
        Single s2 = new Single();
        System.out.print(s1==s2);
    }
}

运行的结果是ture，说明s1 s2 引用的是同一个对象。

5、内部类

java 允许在一个类的内部定义类，这个类成为内部类，这个内部类所在的外部称为外部类。
根据内部类的位置，修饰符，和定义的方式，分为成员内部类，静态内部类，方法内部类。
1）成员内部类
（1）在一个类中除了可以定义成员变量、方法，还可以定义类。这个类就是成员内部类。
（2）成员内部类可以访问外部类的所有成员。
（3）内部类可以在外部类中使用，创建对象。
（4）通过外部类名.内部类名变量名 = new 外部类名().new 内部类名();
的方式创建一个内部类对象，并可以访问其所有变量和方法。

class Outer {
private int num =4; //定义类的成员变量

public void test(){
Inner inner = new Inner();
inner.show();
}

class Inner {
    void show() {
    Log.v(TAG,"num:"+num);
    }
}
}


public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();//创建外部类对象
        outer.test();//调用外部类方法
    }
}

或者直接引用内部类：

public class Test {
    public static void main(String[] args) {
        Outer.Inner  inner = new Outer().new Inner();//创建内部类对象
        Inner.show();//调用外部类方法
    }
}

2)静态内部类
（1）在成员内部类中可以见一个static 修饰，就而静态内部类。
（2）可以不建议外部类对象直接通过外部类类名来访问：
外部类名.内部类名变量名 = new 外部类名。内部类名();
(3)静态内部类只能访问外部类的静态成员。
（4）静态内部类中可以定义静态成员，而在分静态内部类中不允许定义静态成员。

class Outer {
private int num =4; //定义类的成员变量

//定义一个静态内部类
static  class Inner {
    void show() {
    Log.v(TAG,"num:"+num);
    }
}
}


public class Test {
    public static void main(String[] args) {
        Outer.Inner  inner = new Outer.Inner();//创建内部类对象
        inner.show();//调用外部类方法
    }
}

3)方法内部类
方法内部类是指长远方法中定义的类，他只能在当前的方法中被使用。

class Outer {
private int num = 4; 

public void test() {
    class Inner {
        void show() {
                Log.v(TAG,"num:"+num);//访问外部的成员变量。
        } 
    }   
 Inner in = new Inner();//创建内部类对象
 in.show(); //调用内部类方法
   }

}

public class Test {
    public static void main(String[] args) {
        Outer  outer = new Outer();//创建外部类对象
        outer.test();//调用外部类test方法
    }
}

在Outer类的test()方法上定义了一个内部类Inner,由于Inner是方法内部类，因此程序只能在方法中创建该实例的对象，并调用该实例的方法。

参考文档：
Java基础入门　传智博客高教产品研发部　

本人郑重声明，本博客所著文章、图片版权归权利人持有，本博只做学习交流分享所用，不做任何商业用途。访问者可將本博提供的內容或服务用于个人学习、研究或欣赏，不得用于商业使用。同時，访问者应遵守著作权法及其他相关法律的规定，不得侵犯相关权利人的合法权利；如果用于商业用途，须征得相关权利人的书面授权。若以上文章、图片的原作者不愿意在此展示內容，请及时通知在下，將及时予以刪除。