java基础之面向对象（一）

面向对象的三大特性之：

1.封装：包起来，不让外界看到，个人理解将对象的属性和方法写在一个类中，不许外界直接访问，只能通过特定的方式访问（setters和getters）.通常作为实体类出现的.

2.继承：子类通过extends继承父类，每个子类只能有一个父类.继承了父类就拥有父类的属性和方法（非构造方法和私有的属性），还可以继续写自身的属性和方法.通常和多态一块用.

在这之前权限修饰符得先搞明白了：

创建对象：

public class Demo01 {
	public static void main(String[] args) {// 内存模型

		q w = new q();//创建q类的对象，为<span style="color:#ff0000;">这个对象分配一块内存空间</span>，<span style="color:#ff0000;">此对象就拥有q类的引用（属性和方法（不可以直接调用私有属性和方法））</span>
		w.a = "老张";
		q w01 = w;//并没有<span style="color:#ff0000;">new</span>对象，所以<span style="color:#ff0000;">没有新的内存空间，这两个对象共用一块内存，</span>

                 //所以相当于<span style="font-family: Arial, Helvetica, sans-serif;">w和w01共用q类的引用，改变w的引用就是改变w01的引用</span><span style="color:#ff0000;">
</span>                 w01.a = "老李";
		w01.show();
		w.show();// ,w和w01指向同一块内存（同一个引用），所以改变w就是改变w01;
		w01 = new q();//new了一个新对象，创建一块新内存， 此时内存为老李的内存为垃圾内存 ，内存不够用时 会被自动清理
		w = new q();
		w.show();
		w01.show();
	}

}

class q {
	String a;

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

输出：

构造方法：方法名和类名完全一样的方法叫做构造方法.构造方法没有返回值（直接权限修饰符+ 方法名）一个类中可以有若干个构造方法.但是必须保证方法的参数类型或者是参数个数不同。默认调用不带参数的构造方法.

对象的初始化顺序：创建对象，先初始化对象的属性和方法，再初始化构造方法.

public class Demo02 {
	public static void main(String[] args) {
		bag b = new bag();

	}

}

class bag {
	book b = new book(1); // 创建对象

	public bag() {
		System.out.println("书包*1"); // 先初始化对象（属性和方法），在调用构造方法
	}

	book c = new book(2);
}

class book {
	leaf l = new leaf(1);//创建对象

	public book(int page) {
		System.out.println("书本" + page);
	}

	static leaf z = new leaf(2);// <span style="color:#ff0000;">static关键字先初始化，并且只被初始化一次</span>
}

class leaf {
	public leaf(int page) {
		System.out.println("书页" + page);
	}
}

程序的执行流程：

因为bag类中有创建book类的对象，所以先执行new book(),初始化book对象的属性和方法，又因为book类中，new了static对象leaf,所以先执行leaf初始化操作（属性和方法），........

输出：

 

方法的重载：一个类中有很多方法，这些方法的名字可以相同，但是要保证方法的参数类型不同，或者是参数类型相同但参数个数不同

例（这里写的构造方法的重载）

package javaTest;

public class TestDemo {
public static void main(String[] args) {
Father father = new Father();// 实例化对象
father.name = "晓宁";
father.age = 20; // 给属性赋值
father.show();// 调用方法
Father fatherTwo = new Father(21, "晓宁");// 在创建对象的时候初始化属性的值
fatherTwo.show();
}
}

class Father {
public int age;
public String name;

Father() { // 默认的构造方法

}

public Father(int age, String name) {// 传参的构造方法

this.age = age;
this.name = name;
}

public Father(int age) {
this.age = age;
}

public void show() {
System.out.println("名字：" + name + ", 年龄：" + age);
}

}

this关键字：表示类本身的对象，可以出现在实例方法和构造方法中，不可以出现在类方法中。

this.age  就是调用这个类本身的age属性，

封装和继承共用时：

class a { // 父类
	private String name = "wangwu";  //私有属性 只能通过get、set方法访问   成员变量
	private int age = 30;  

 //通过eclipse自动生成Getters和Setters方法
	public void setAge(int age) {
		this.age = age;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;

	}

	public String getName() {
		return name;
	}

	public void tell() {
		System.out.println(this.getAge() + this.getName());
	}
}

class b extends a { //<span style="color:#ff0000;"> 继承父类</span>  同时拥有父类的方法和属性（私有属性、构造方法除外）
	private int score;

	public void setScore(int score) {
		this.score = score;//<span style="font-family: Arial, Helvetica, sans-serif;">this在这指的是这个类本身。</span>

	}

	public int getScore() {
		return score;
	}

	public void Tell() {
		System.out.println(this.getScore() + this.getAge()); // 输出150，100+ 50
	}
}

public class extends01 {
	public static void main(String args[]) {
		b v = new b(); // <span style="color:#ff0000;">创建子类的对象，这个对象获得一个引用</span>（<span style="color:#ff0000;">包括子类和父类的非私有的属性和方法</span>），可以操作这个引用做一些逻辑操作，如下：
		v.setAge(50);
		v.setName("djsah"); //设置子类对象的name
		v.setScore(100);
		v.tell();
		v.Tell();
	}
}

面向对象的内容很多，我只是把一部分内容稍微写了写，如果想深入研究，买书看吧，..........

下一篇将详细讲述多态和继承的混合使用..