黑马程序员——java中面向对象基础

------Java培训、Android培训、期待与您交流！ -------

一、面向对象概念

java 是面向对象的编程语言，面向对象程序设计是相对于面向过程程序设计的另一种程序设计方法。它的基本思想是使用类、对象、继承、封装、消息等基本概念进行程序设计。
对象：可以是现实中存在的客观事物也可以是无形的抽象事物。一个对象由一组属性和一组对属性进行操作的方法构成。如：汽车这个对象，有轮胎数和颜色属性，也有对车进行操作即开车方法。
类：具有相同属性和相同行为的一组对象。广义来讲，具有共同性质事物的集合就成为类。类中包含对象的属性和方法，在java中体现为对变量的定义和对变量进行操作的方法的定义。
封装性：将对象的某些属性隐藏起来，不允许外界知道或修改，将描述对象属性的变量和实现对象功能的方法定义为一个程序单位进行封装，定义不同的访问权限，提高程序的安全性。继承性：首先拥有反映事物一般特性的类，然后在其基础上派生出反映特殊事物的类。如已有的汽车的类，该类中描述了汽车的普遍属性和行为，进一步再产生轿车的类，轿车的类是继承于汽车类，轿车类不但拥有汽车类的全部属性和行为，还增加轿车特有的属性和行为。
继承性：在反映事物一般特性的类的基础上派生出反映特殊事物的类。如已有的汽车的类，该类中描述了汽车的普遍属性和行为，进一步再产生轿车的类，轿车的类是继承于汽车类，轿车类不但拥有汽车类的全部属性和行为，还增加轿车特有的属性和行为。java中，被继承的类称为父类或超类，经继承产生的类称为子类或派生类。继承提高了代码的复用性，也为程序的修改和扩展提供了便利。java支持单继承不支持多继承，而是通过接口的多实现方式实现多继承的功能。多态是允许程序中出现重名现象。

多态性：某一类事物的多种存在形态。如：动物中存在猫、狗等不同种类。在java中是一个对象对应着不同类型，父类或接口引用指向或接收自己的子类对象，多态的存在提高了程序的扩展性和后期可维护性。

二、类与对象

1、类的定义格式：

黑马程序员——java中面向对象基础

范例：

class Person {

String name;

int age;

void talk() {

System.out.println("我是： " + name + "，今年： " + age + "岁 ");

}

}

说明：

1、程序首先用 class 声明了一个名为 Person 的类，这里 Person 是类的名称。

2、在类中，先声明了两个属性 name 和 age， name 为 String（字符串类型）型、age 为 int（整型）型。

3、之后，声明了一个 talk()方法，此方法用于向屏幕打印信息。

2、创建对象和访问对象

创建对象格式：类名对象名 = new 类名（）；

访问对象格式：访问属性：对象名称.属性名；

访问方法：对象名称.方法名()；

范例：

class PersonDemo {

public static void main(String[] args) {

Person p = new Person();//创建Person对象

p.name = "张三";//访问Person类中的name属性并赋值

p.age = 25;//访问Person类中的age属性并赋值

p.talk();//访问Person类中的talk方法

}

}

3、对象在内存中的体现

4、类的封装性

在实际开发中，会将对象的某些属性进行封装并对外提供方法进行访问。程序如下：

class Person {
	//对name和age属性进行私有化封装
	private String name;
	private int age;

	void talk() {
		System.out.println("我是： " + name + "，今年： " + age + "岁 ");
	}

	//对外提供方法访问name和age属性
	public void setName(String str) {
		name = str;
	}

	public void setAge(int a) {
		if (a > 0)
			age = a;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}
}

public class PersonDemo1 {
	public static void main(String[] args) {
		// 声明并实例化 Person 对象 p
		Person p = new Person();
		// 给 p 中的属性赋值
		p.setName("张三");

		// 在这里将 p 对象中的年龄赋值为25 岁  ;
		p.setAge(25) ;
		// 调用 Person 类中的 talk()方法
		p.talk();
	}
};

输出结果：

我是：张三，今年： 25岁

5、成员变量与局部变量

成员变量：

1. 成员变量定义在类中，在整个类中都可以被访问。

2. 成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。

3. 成员变量有默认初始化值。

局部变量：

1. 局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。

2. 局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。

3. 局部变量没有默认初始化值。

6、匿名对象

匿名对象其实就是没有名字的对象，是对象定义的简写格式。如：new Person();

1、当对象方法仅进行一次调用时，就可以简化为匿名对象；
new Person().name = "李四"；
new Person().run();

2、匿名对象可以作为实际参数进行传递。
show(new Person());相当于Person p = new Person();show(p);

7、基本数据类型和引用数据类型传递

三、面向对象中重点关键字总结

abstract:abstract关键字用于修饰抽象类和抽象方法。abstract 类不能实例化，须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。否则，这个子类还是抽象类。abstract 关键字不能应用于 static、private 或 final 方法，因为这些方法不能被重写，因此，不能在子类中实现。如：

public abstract class MyClass { }

public abstract String myMethod();

final: final是一个修饰符，可以修饰类，方法，变量。
final修饰的类不可以被继承。
final修饰的方法不可以被覆盖。
final修饰的变量是一个常量，只能赋值一次。如：
public static final double MY_PI = 3.14;

extend: extends 关键字用在 class 或 interface 声明中，用于指示所声明的类或接口是其名称后跟有extends 关键字的类或接口的子类。如：
public class Students extends Person;//Students类继承Person类的所有变量和方法

implements: implements关键字在class声明中使用，以指示所声明的类提供了在implements 关键字后面的名称所指定的接口中所声明的所有方法的实现。如：
public class Computer implements Mouse；//Computer类实现了Mouse接口

   package: package关键字指定在Java 源文件中声明的类所驻留的Java 包。如：
package com.mycompany;
public class MyClass { }

private:private 关键字是访问控制修饰符，可以应用于类、方法或变量，只能在声明 private（内部类、方法或字段的类中引用这些类、方法或变量。在类的外部或者对于子类而言，它们是不可见的。所有类成员的默认访问范围都是 package 访问，也就是说，除非存在特定的访问控制修饰符，否则，可以从同一个包中的任何类访问类成员。如：
public class MyPrivateClass{
private class MyPrivateClass
{ }
private int i;
private String myMethod(){
} }

protected: protected关键字是可以应用于类、方法或变量的访问控制修饰符。可以在声明 protected 类、方法或变量的类、同一个包中的其他任何类以及任何子类（无论子类是在哪个包中声明的）中引用这些类、方法或变量。如：
public class MyProtectedClass{
protected class MyPrivateClass
{ }
protected int i;
protected String myMethod(){
} }

public: public 关键字是可以应用于类、方法或变量的访问控制修饰符。在其他任何类或包中可以引用public 类、方法或变量。如：
public class MyPublicClass{
public class MyPrivateClass
{ }
public int i;
public String myMethod(){
} }

   static: static是一个修饰符，用于修饰成员； static修饰的成员被所有的对象所共享； static优先于对象存在，因为static的成员随着类的加载就已经存在了； static修饰的成员多了一种调用方式，就可以直接被类名所调用：类名.静态成员，如： MyClass 类外部的代码以 MyClass.getNumObjects() 的形式调用 getNumObjects() static 方法； static修饰的数据是共享数据，对象中的存储的是特有数据。static关键字与this、super关键不共存与同一个类中。
public class MyStaticClass{
public final static int MAX_OBJECTS = 100;
static int _numObjects = 0;
static class MyStaticClass{ }
static int getNumObjects(){
} }
super: super 关键字用于引用使用该关键字的类的父类。作为独立语句出现的 super 表示调用父类的构造方法。 super方法名() 表示调用父类的方法。如：
public class MyClass extends FuClass {
public MyClass(String arg) {
super(arg); }
public String myStringMethod(){
return super.otherStringMethod();}

   this: this关键字用于引用当前对象。可以用于区别成员变量和局部变量重名。另外也可用于构造函数中调用其他构造函数。如：
public class MyClass{
int number;
public MyClass(int number){
this.number = number;
} }

---- --Java培训、Android培训、期待与您交流！ -------

秒客网

黑马程序员——java中面向对象基础

相关文章