第4章 4.1 面向对象（上）

面向对象（上）

1.面向对象基本概念 2.类与对象 3.类和对象的定义格式 4.对象与内存分析 5.封装性 6.构造方法 7.this 关键字 8.值传递与引用传递 9.对象的一对一关系 10.static 关键字 11.main 方法分析 12.代码块 13.单例设计模式 14.对象数组与管理

·
1.类和对象
类：类是一组具有相同特征（属性）与行为（方法）的事物集合

new 关键字：表示向内存申请空间，也表示实例化一个对象，创建一个对象

当一个堆中的对象没有被任何引用变量所指向时，该对象会被JVM的GC程序认为是垃圾程序，从而被回收

2.封装性
封装的概念
1）面向对象三大特征之一
2）封装就是隐藏实现细节，仅对外提供访问接口
封装有：属性的封装、方法的封装、类的封装、组件的封装、模块化的封装、系统级封装
封装的好处
模块化、信息隐藏、代码重用、插件化易于调试、具有安全性
缺点：影响执行效率
private关键字：访问权限修饰符 私有的属性或方法，只能在本类中访问，想要在类外部访问私有属性，需要提供公有的方法来间接访问（getset方法）

3.成员变量：在类中定义
局部变量：在方法中定义或者方法的参数

4.对象的一对一关系

public class Test1 {

	public static void main(String[] args) {
		Hero hero = new Hero("张飞",300);
		Weapon weapon = new Weapon("丈八蛇矛",5);
		//把两个对象关联起来
		hero.setWeapon(weapon);
		weapon.setHero(hero);
		
		//通过英雄来获取他的信息
		String name = hero.getName();
		int age = hero.getAge();
		Weapon w = hero.getWeapon();
		System.out.println("我是"+name+",我"+age+"岁，我的武器是"+w.getName()+",排行"+w.getGrade()+"级");
		
	}

}
class Hero{
	private String name;
	private int age;
	private Weapon weapon;
	public void setWeapon(Weapon weapon) {
		this.weapon = weapon;
	}
	public Weapon getWeapon() {
		return weapon;
	}
	public Hero() {}
	public Hero(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}
class Weapon{
	private String name;
	private int grade;
	private Hero hero;
	public void setHero(Hero hero) {
		this.hero = hero;
	}
	public Hero getHero() {
		return hero;
	}
	public Weapon() {}
	public Weapon(String name,int grade) {
		this.name = name;
		this.grade = grade;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getGrade() {
		return grade;
	}
	public void setGrade(int grade) {
		this.grade = grade;
	}
	

5.static 关键字
1).静态变量或方法不属于对象，依赖类
2).静态变量是全局变量，生命周期从类被加载后一直到程序结束
3).静态变量只有一份，在静态方法中存储
4).静态变量是本类所有对象共享一份
5).建议不要使用对象名去调用静态数据，直接使用类名
6).static修饰一个方法，那么该方法属于类，不属于对象，直接用类名调用
7).静态方法不能访问非静态属性和方法，只能访问静态

6.代码块
1、普通代码块-在方法中写的代码块
2、构造代码块-是在类中定义的代码块，在创建对象时被调用，优于构造方法执行
3、在类中使用static声明的代码块称为静态代码块
在第一次使用的时候被调用，只会执行一次，优于构造代码块执行
4、同步代码块（多线程）

7. 对象数组与管理

package test;
import java.util.*;
public class Test2 {

	public static void main(String[] args) {
		ChickenManager cm = new ChickenManager(5);
		cm.add(new Chicken(1, "张三", 10));
		cm.add(new Chicken(2, "张三", 10));
		cm.add(new Chicken(3, "张三", 10));
		cm.add(new Chicken(4, "张三", 10));
		cm.add(new Chicken(5, "张三", 10));
		cm.add(new Chicken(6, "张三", 10));
		System.out.println("数组的长度是："+cm.length());
		System.out.println("--------find---------");
		Chicken c = cm.find(6);
		c.print();
		System.out.println("----------findAll-----------");
		cm.findAll();
		System.out.println("--------update---------");
		cm.update(new Chicken(1, "王五", 20));
		cm.findAll();
		System.out.println("--------delete---------");
		cm.delete(4);
		cm.findAll();
	}
}
class ChickenManager{
	private Chicken[] cs = null;
	private int count = 0;
	
	public ChickenManager(int size) {
		if(size > 0) {
			cs = new Chicken[size];
		}else {
			cs = new Chicken[5];
		}
	}
	public int length() {
		return cs.length;
	}
	//添加：实现动态数组
	public void add(Chicken c) {
		if(count >= cs.length) {//数组已满，需要扩充
			//算法1：扩充原来数组的一半cs.length*3/2+1
			//算法2：扩充原来数组的一倍cs.length*2
			int newLength = cs.length*2;
			cs = Arrays.copyOf(cs, newLength);
			
		}
		cs[count] = c;
		count ++;
		
	}
	//删除
	public void delete(int id) {
		for(int i = 0;i < count;i++) {
			if(cs[i].getId() == id) {
				for(int j = i;j < count-1;j++) {
					cs[j] = cs[j+1];
				}
				cs[count-1] = null;
				count--;
				break;
			}
		}
	}
	//更新
	public void update(Chicken c) {
		Chicken temp = find(c.getId());
		if(temp != null) {
			temp.setName(c.getName());
			temp.setAge(c.getAge());
		}
	}
	//查找
	public Chicken find(int id) {
		for(int i = 0;i < count;i++) {
			if(cs[i].getId() == id) {
				return cs[i];
			}
		}
		return null;
	}
	public void findAll() {
		for(int i = 0;i < count;i++) {
			cs[i].print();
		}
	
	}
}
class Chicken{
	private int id;
	private String name;
	private int age;
	public Chicken(int id,String name,int age) {
		this.age = age;
		this.id = id;
		this.name = name;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void print() {
		System.out.println("id="+id+",name="+name+",age="+age);
	}
}