黑马程序员-java学习之面向对象

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------

1.    封装 （encapsulation）

封装就是将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。是为实现各式各样的数据传送，将被传送的数据结构映射进另一种数据结构的处理方式。

private：私有，是一个权限修饰符。用于修饰成员。私有的内容只在本类中有效

注意：私有只是封装的一种体现而已。

class Person {
	// 私有
	private int age;

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

	public int getAge() {
		return age;
	}

	public void haha(int a) {
		if (a > 0 && a < 130) {
			age = a;
			speak();
		} else {
			System.out.println("错误的数据");
		}
	}

	void speak() {
		System.out.println("age=" + age);
	}
}

public class PersonDemo {
	public static void main(String[] args) {
		Person p = new Person();
		// p.age = -20;
		p.haha(-20);
		p.speak();
	}

	public static void selectSort(int[] arr) {
	}

	private static void swap(int[] arr, int a, int b) {
	}
}

构造函数：构建创造对象时调用的函数。作用：可以给对象进行初始化。

创建对象都必须要通过构造函数初始化。

一个类中如果没有定义过构造函数，那么该类中会有一个默认的空参数构造函数。

如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。

一般函数和构造函数什么区别呢？

构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。

一般函数：对象创建后，需要函数功能时才调用。

构造函数：对象创建时，会调用只调用一次。

一般函数：对象创建后，可以被调用多次。

什么时候定义构造函数呢？

在描述事物时，该事物一存在就具备的一些内容，这些内容都定义在构造函数中。

构造函数可以有多个，用于对不同的对象进行针对性的初始化.

多个构造函数在类中是以重载的形式来体现的。

细节:

1，构造函数如果完成了set功能。set方法是否需要。

2，一般函数不能直接调用构造函数。

3，构造函数如果前面加了void就变成了一般函数。

4，构造函数中是有return语句的。

class Person {
	private String name;
	private int age;

	// 定义一个Person类的构造函数。
	Person()// 构造函数，而且是空参数的。
	{
		name = "baby";
		age = 1;
		System.out.println("person run");
	}

	// 如果有的孩子一出生就有名字。
	Person(String n) {
		name = n;
	}

	public void setName(String n) {
		name = n;
	}

	Person(String n, int a) {
		name = n;
		age = a;
	}

	public void speak() {
		System.out.println(name + ":" + age);
	}
}

class ConsDemo {
	public static void main(String[] args) {
		Person p = new Person();
		//
		p.speak();
		Person p1 = new Person("旺财");
		p1.setName("旺旺");
		p1.speak();
		Person p2 = new Person("小强", 10);
		p2.speak();
	}
}

3.     this关键字

当成员变量和局部变量重名，可以用关键字this来区分。

this : 代表对象。代表哪个对象呢？当前对象。

this就是所在函数所属对象的引用。

简单说：哪个对象调用了this所在的函数，this就代表哪个对象。

this也可以用于在构造函数中调用其他构造函数。

注意：只能定义在构造函数的第一行。因为初始化动作要先执行。

class Person {
	private String name;
	private int age;

	Person() {
		name = "baby";
		age = 1;
		System.out.println("person run");
	}

	Person(String name) {
		this();
		this.name = name;
	}

	Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public void speak() {
		System.out.println(this.name + ":" + this.age);
	}

	/*
	 * 判断是否是同龄人。
	 */
	public boolean compare(Person p) {
		/*
		 * if(this.age==p.age) return true; else return false;
		 */
		return this.age == p.age;
	}
}

class ThisDemo {
	public static void main(String[] args) {
		Person p1 = new Person("aa", 30);//
		Person p2 = new Person("zz", 12);
		p2.compare(p1);
		// new Person();
		// Person p = new Person("旺财", 30);
		// p.speak();
		// Person p1 = new Person("小强");
		// p1.speak();
	}
}

4.    static关键字

static的特点：

1，static是一个修饰符，用于修饰成员。

2，static修饰的成员被所有的对象所共享。

3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。

4，static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。

5，static修饰的数据是共享数据，对象中的存储的是特有数据。

成员变量和静态变量的区别？

1，两个变量的生命周期不同。

成员变量随着对象的创建而存在，随着对象的被回收而释放。

静态变量随着类的加载而存在，随着类的消失而消失。

2，调用方式不同。

成员变量只能被对象调用。

静态变量可以被对象调用，还可以被类名调用。

3，别名不同。

成员变量也称为实例变量。

静态变量称为类变量。

4，数据存储位置不同。

成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.

静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.

静态使用的注意事项：

1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)

2，静态方法中不可以使用this或者super关键字。

3，主函数是静态的。

class Person {
	String name;// 成员变量，实例变量
	static String country = "CN";// 静态变量。类变量

	public void show() {
		System.out.println(Person.country + ":" + this.name);
	}
}

class StaticDemo {
	int num = 4;

	public static void main(String[] args) {
		// Person p = new Person();
		// p.name = "小强";
		// p.show();
		// System.out.println(p.country);
		// System.out.println(Person.country);
		// Person.show();
		new StaticDemo().show();
	}

	public void show() {
		System.out.println(num);
	}
}

静态什么时候用？

1，静态变量。

当分析对象中所具备的成员变量的值都是相同的 。

这时这个成员就可以被静态修饰。

只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。

如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

2，静态函数。

函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。

简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。

如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，

但是非静态需要被对象调用，而仅创建对象调用非静态的

没有访问特有数据的方法，该对象的创建是没有意义。

class Demo {
	int age;
	static int num = 9;

	Demo(int age) {
		this.age = age;

	}

	public static void speak() {
		System.out.println(num);
	}

	public void show() {
		System.out.println(age);
	}
}

class StaticDemo3 {
	public static void main(String[] args) {
		// Demo d = new Demo(30);
		// d.speak();
		Demo.speak();
		// System.out.println("Hello World!");
	}
}

静态代码块。

随着类的加载而执行。而且只执行一次。

作用：

用于给类进行初始化。

class StaticCode {
	static int num;
	static {
		num = 10;
		// num *= 3;
		System.out.println("hahahah");
	}

	StaticCode() {
	}

	static void show() {
		System.out.println(num);
	}
}

class Person {
	private String name;
	{// 构造代码块。可以给所有对象进行初始化的。
		System.out.println("constructor code ");
		// cry();
	}
	static {
		System.out.println("static code");
	}

	Person()// 是给对应的对象进行针对性的初始化。
	{
		name = "baby";

		// cry();
	}

	Person(String name) {
		this.name = name;
		// cry();
	}

	public void cry() {
		System.out.println("哇哇");
	}

	public void speak() {
		System.out.println("name:" + name);
	}

	static void show() {
		System.out.println("show run");
	}
}

class StaticCodeDemo {
	static {
		// System.out.println("a");
	}

	public static void main(String[] args) {
		// Person p = null;
		// p.speak();
		// Person.show();
		// Person p1 = new Person();
		// p1.speak();
		// Person p2 = new Person("旺财");
		// p2.speak();
		// new Person();
		// new StaticCode().show();
		// new StaticCode().show();

		// StaticCode.show();
		// System.out.println("b");
	}
}

5.    main函数

public static void main(String[] args)

主函数特殊之处：

1，格式是固定的。

2，被jvm所识别和调用。

public:因为权限必须是最大的。

static:不需要对象的,直接用主函数所属类名调用即可。

void：主函数没有具体的返回值。

main:函数名，不是关键字，只是一个jvm识别的固定的名字。

String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。

class MainDemo {
	public static void main(String[] args) // new String[0]
	{
		/**/
		//
		System.out.println(args);// [Ljava.lang.String;@c17164
		System.out.println(args.length);
		for (int x = 0; x < args.length; x++)
			System.out.println(args[x]);
	}
}

6.    继承

关于成员变量（案例一）

在子父类中，成员的特点体现。

1，成员变量。

2，成员函数。

3，构造函数。

1，成员变量。

当本类的成员和局部变量同名用this区分。

当子父类中的成员变量同名用super区分父类。

this和super的用法很相似。

this:代表一个本类对象的引用。

super：代表一个父类空间。

class Fu {
	private int num = 4;

	public int getNum() {
		return num;
	}
}

class Zi extends Fu {
	private int num = 5;

	void show() {
		System.out.println(this.num + "....." + super.getNum());
	}
}

class ExtendsDemo2 {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}

关于成员函数（案例二）

当子父类中出现成员函数一模一样的情况，会运行子类的函数。

这种现象，称为覆盖操作。这时函数在子父类中的特性。

函数两个特性：

1，重载。同一个类中。overload

2，覆盖。子类中。覆盖也称为重写，覆写。override

覆盖注意事项：

1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。

2，静态只能覆盖静态，或被静态覆盖。

class Fu {
	public static void show() {
		System.out.println("fu show run");
	}
}

class Zi extends Fu {
	public static void show() {
		System.out.println("Zi show run");
	}
}

class ExtendsDemo3 {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show();
	}
}

7.    final关键字

1，final是一个修饰符，可以修饰类，方法，变量。

2，final修饰的类不可以被继承。

3，final修饰的方法不可以被覆盖。

4，final修饰的变量是一个常量，只能赋值一次。

为什么要用final修饰变量。其实在程序如果一个数据是固定的，

那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。

而且这个变量名称的值不能变化，所以加上final固定。

写法规范：常量所有字母都大写，多个单词，中间用_连接。

class Fu {
	void method() {
		// 调用了底层系统的资源。
	}
}

class Zi extends Fu {
	public static final double MY_PI = 3.14;
	static final int x = 7;

	void method() {
		// final int x = 9;
		// x = 9;
		final int NUMBER = 9;
		System.out.println(MY_PI);
	}
}

class FinalDemo {
	public static void main(String[] args) {
		System.out.println("Hello World!");
	}
}

8.    抽象类

抽象：笼统，模糊，看不懂！不具体。

特点：

1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。

抽象方法必须定义在抽象类中。该类必须也被abstract修饰。

2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。

3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。

否则，这个子类还是抽象类。

1，抽象类中有构造函数吗？

有，用于给子类对象进行初始化。

2，抽象类可以不定义抽象方法吗？

可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。

通常这个类中的方法有方法体，但是却没有内容。

abstract class Demo

{

void show1()

{}

void show2()

{}

}

54

3，抽象关键字不可以和那些关键字共存?

private 不行

static 不行

final 不行

4，抽象类和一般类的异同点。

相同点：

抽象类和一般类都是用来描述事物的，都在内部定了成员。

不同：

1，一般类有足够的信息描述事物。

抽象类描述事物的信息有可能不足。

2，一般类中不能定义抽象方法，只能定非抽象方法。

抽象类中可定义抽象方法，同时也可以定义非抽象方法。

3，一般类可以被实例化。

抽象类不可以被实例化。

4，抽象类一定是个父类吗？

是的。因为需要子类覆盖其方法后才可以对子类实例化。

9.    接口

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用

另一种形式定义和表示，就是接口 interface。

定义接口使用的关键字不是class，是interface.

对于接口当中常见的成员：而且这些成员都有固定的修饰符。

1，全局常量: public static final

2，抽象方法。public abstract

由此得出结论，接口中的成员都是公共的权限.

interface Demo {

public static final int NUM = 4;

 

public abstract void show1();

 

public abstract void show2();

 

}

 

// 类与类之间是继承关系，类与接口直接是实现关系。

/*

 * 接口不可以实例化。 只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。 否则，这个子类就是一个抽象类。

 */

class DemoImpl implements /* 实现 */Demo {
	public void show1() {
	}

	public void show2() {
	}
}

/*
 * 在java中不直接支持多继承，因为会出现调用的不确定性。 所以java将多继承机制进行改良，在java中变成了多实现。 一个类可以实现多个接口。
 */
interface A {
	public void show();
}

interface Z {
	public int add(int a, int b);
}

class Test implements A, Z// 多实现
{
	public int add(int a, int b) {
		return a + b + 3;
	}

	/**/
	public void show() {
	}
}

/*
 * 一个类在继承另一个类的同时，还可以实现多个接口。
 */
class Q {
	public void method() {
	}
}

abstract class Test2 extends Q implements A, Z {
}

/*
 * 接口的出现避免了单继承的局限性。
 */
interface CC {
	void show();
}

interface MM {
	void method();
}

interface QQ extends CC, MM// 接口与接口之间是继承关系，而且接口可以多继承。
{
	void function();
}

class WW implements QQ {
	// 覆盖3个方法。
	public void show() {
	}

	public void method() {
	}

	public void function() {
	}
}

class InterfaceDemo {
	public static void main(String[] args)

	{
		Test t = new Test();
		t.show();
		// DemoImpl d = new DemoImpl();
		// System.out.println(d.NUM);
		// System.out.println(DemoImpl.NUM);
		// System.out.println(Demo.NUM);
	}
}

10.多态

class 动物

{}

class 猫 extends 动物

{}

class 狗 extends 动物

{}

猫 x = new 猫();

动物 x = new 猫();//一个对象，两种形态。

猫这类事物即具备者猫的形态，又具备着动物的形态。

这就是对象的多态性。

简单说：就是一个对象对应着不同类型.

多态在代码中的体现：

父类或者接口的引用指向其子类的对象。

多态的好处：

提高了代码的扩展性，前期定义的代码可以使用后期的内容。

多态的弊端：

前期定义的内容不能使用(调用)后期子类的特有内容。

多态的前提：

1，必须有关系，继承，实现。

2，要有覆盖。

abstract class Animal {
	abstract void eat();
}

class Dog extends Animal {
	void eat() {
		System.out.println("啃骨头");
	}

	void lookHome() {
		System.out.println("看家");
	}
}

class Cat extends Animal {
	void eat() {
		System.out.println("吃鱼");
	}

	void catchMouse() {
		System.out.println("抓老鼠");
	}
}

class Pig extends Animal {
	void eat() {
		System.out.println("饲料");
	}

	void gongDi() {
		System.out.println("拱地");

	}
}

class DuoTaiDemo {
	public static void main(String[] args) {
		// Cat c = new Cat();
		// c.eat();
		// c.catchMouse();
		Animal a = new Cat(); // 自动类型提升，猫对象提升了动物类型。但是特有功能无法s访问。
		// 作用就是限制对特有功能的访问。
		// 专业讲：向上转型。将子类型隐藏。就不用使用子类的特有方法。
		// a.eat();
		// 如果还想用具体动物猫的特有功能。
		// 你可以将该对象进行向下转型。
		// Cat c = (Cat)a;//向下转型的目的是为了使用子类中的特有方法。
		// c.eat();
		// c.catchMouse();
		// 注意：对于转型，自始自终都是子类对象在做着类型的变化。
		// Animal a1 = new Dog();
		// Cat c1 = (Cat)a1;//ClassCastException
		/*
		 * Cat c = new Cat(); // Dog d = new Dog(); // c.eat(); method(c); //
		 * method(d); // method(new Pig());
		 */
		method(new Dog());
	}

	public static void method(Animal a)// Animal a = new Dog();
	{
		a.eat();

		if (a instanceof Cat)// instanceof：用于判断对象的具体类型。只能用于引用数据类型判断
		//
		// 通常在向下转型前用于健壮性的判断。
		{
			Cat c = (Cat) a;
			c.catchMouse();
		} else if (a instanceof Dog) {
			Dog d = (Dog) a;
			d.lookHome();
		} else {
		}
	}
	/*
	 * public static void method(Cat c) { c.eat(); } public static void
	 * method(Dog d) { }
	 */
}

11.内部类

内部类访问特点：

1，内部类可以直接访问外部类中的成员。

2，外部类要访问内部类，必须建立内部类的对象。

一般用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。

这时就是还有的事物定义成内部类来描述。

内部类能直接访问外部类中成员，是因为内部类持有了外部类的引用，即外部类名.this。

内部类也可以存放在局部位置上，但是内部类在局部位置上只能访问局部中被final修饰的局部变量。

class Outer {
	private static int num = 31;

	class Inner// 内部类。
	{
		void show() {
			System.out.println("show run..." + num);
		}
		/*
		 * static void function()//如果内部类中定义了静态成员，该内部类也必须是静态的。 {
		 * System.out.println("function run ...."+num); }
		 */
	}

	public void method() {
		Inner in = new Inner();
		in.show();
	}
}

class InnerClassDemo {
	public static void main(String[] args) {
		// Outer out = new Outer();

		// out.method();
		// 直接访问外部类中的内部类中的成员。
		// Outer.Inner in = new Outer().new Inner();
		// in.show();
		// 如果内部类是静态的。 相当于一个外部类
		// Outer.Inner in = new Outer.Inner();
		// in.show();
		// 如果内部类是静态的，成员是静态的。
		// Outer.Inner.function();
	}
}

匿名内部类，就是内部类的简写格式。

必须有前提：

内部类必须继承或者实现一个外部类或者接口。

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类or接口(){子类内容}

abstract class Demo {
	abstract void show();
}

class Outer {
	int num = 4;

	/*
	 * class Inner extends Demo { void show() {
	 * System.out.println("show ..."+num); } }
	 */
	public void method() {
		// new Inner().show();
		new Demo()// 匿名内部类。

		{
			void show() {
				System.out.println("show ........" + num);
			}
		}.show();
	}
}

class InnerClassDemo4 {
	public static void main(String[] args) {
		new Outer().method();
	}
}

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ----------------------