Androi开发从零开始之java-面对对象基础

package test;

/**
 * 作者:钟志钢 内容:面对对象(类,对象,构造函数) 时间:2013-3-6 
 * 	三大特征:封装,继承,多态,(抽象)
 * 1, 变量命名方法: 骆峰法,匈牙利法: myNameIs
 * 		下划线法:my_name_is
 * 2, 构造方法
 * 		默认是没有参数
 * 		一个类可以有很多个构造方法(参与不同,数量与属性)
 * 		没有标识(void)
 * 		方法名与类名相同
 * 		主要用来初始化,实例化时会自动调用相应的构造函数(用参数对应)
 * 		子类调用无参数构造方法时,会默认先调用父类的构造函数
 * 3, this的作用
 * 		可读性强,对象明确
 * 		一般指代成员变量,属于一个对象的,不是类的
 * 		每一个对象都分配了this
 * 		只能在类定义时使用
 * 4, 类变量(static):整个类共同使用的变量,访问和修改的都是同一个变量
 * 		格式:访问修饰符 + static + 数据类型 + 变量名
 * 		访问: 类名.变量名,或者,类对象名.变量名
 * 5, 类方法,静态方法,全局方法
 * 		只能访问类变量(静态);但非静态方法可以访问类变量
 * 6, 抽象:
 * 		把共同的属性和方法集合起来,形成一个类,就是抽象方法
 * 		比如:银行账号,有属性:用户名,账号,密码等 ,有共同方法:取款,存款等
 * 7, 封装:(电视机)
 * 		数据(属性和方法)被保护在类内部,java中原则:尽可能把方法和变量变成私有的,只能通过成员方法进行操作
 * 		访问控制修饰符:public(全公开),protected(包内),默认(不包括子类),private(只能类内),
 * 		包的三大作用:区分同名的类,分类管理类,控制访问范围
 * 8, 继承:class 子类 expends 父类
 * 		子类会自动拥有父类非private的方法和属性
 * 		子类只能继承一个父类,一个父类只有一个只类,(一个父亲可以有多个孩子,一个孩子只有一个亲生父亲)
 * 		所有的类,都是Object的子类
 * 9, 方法的重载(overload)与覆盖(override重写)
 * 		方法重载:同一类下,方法名相同(同一种功能),参数不同(不同实现方式):参数类型\个数\顺序至少有一个不同;
 * 		方法重写:子类的一个方法与父类的某个方法名称,返回类型和参数一样,就不再继承父类的那个方法,直接用子类的这个方法覆盖
 * 				重写时不能缩小父类的方法访问范围
 * 10,多态: 一个对象的多种状态
 * 		
 * @author Administrator
 * 
 */
public class 面对对象 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		面对对象 面 = new 面对对象();

	}

	public 面对对象() {
		// 实例化一个对象
		Cat cat1 = new Cat(3, "小花");// 需要调用构造函数
		Cat cat3 = new Cat();// 当类中存在有参数的构造函数而又没有写有参数的构造函数时不能调用无参函数
		// 分步实例化
		Cat cat2;// 一般用在全局声明
		cat2 = new Cat(4, "小黑");// 一般用在方法内部实例化
		cat3.age = 5;
		cat3.name = "小红";
		cat3.weight = 3;
		Cat cat4 = new Cat1();// 向上
		// 定义其它属性
		cat1.weight = 2;
		cat2.weight = 1;
		System.out.println("小花的名字是:" + cat1.name + ",年龄是:" + cat1.age + ",体重是:"
				+ cat1.weight);
		cat1.jump();// 调用cat的方法,每运行一个函数时,建立一个栈,各不相干,成员变量名可以相同
		System.out.println(cat1.count(100));// 算术
		System.out.println(cat1.count(20, 100));// 算术
		Cat c = cat1;// 内存中只存在一个实例(new),一旦改变,则两个都变
		// cat1.age = 10;
		// c.age = 9;
		System.out.println("c==" + c.age);
		// 垃圾回收机制
		cat3 = null;// 这样之后,虚拟机在适当的时候自动回收cat3,程序员无需管;
		int a = 9;
		int b = a;
		a = 10;
		System.out.println("b = " + b);
		// 调用打印乘法表的方法
		cat1.juju(4);
		int mys[][] = new int[][] { { 11, 12, 13 }, { 21, 22, 23 },
				{ 31, 32, 33 }, };
		cat1.zhangzi(mys);// 数组转置
		//静态方法使用
		System.out.println("Cat.total=="+Cat.total);
		//一般情况下都这样使用
		System.out.println("Cat.total==" + Cat.mytotal() );
		
		//封装
		Clerk c1 = new Clerk("小花", 20, 3.9f);
		System.out.println(c1.name);
		//System.out.println(c1.sal);//如果不在一个类中,是能访问private变量的
		//可以用如下方法
		System.out.println(c1.getsal());
		
		Cat1 cat = new Cat1();
		
		
	}

	// 写一个类继承自Cat,会继承其全部属性和方法(如果可以继承的话);
	class Cat1 extends Cat {
		int color ;//新加入一个属性
		public void jump(){
			//重写了jump方法
			System.out.println("我是cat1,我能跳三米高");
		}
		
	}
	class Cat2 extends Cat{
		int big;
	}

	// 定义一个猫类,代表一类事物
	static class Cat {
		// 成员变量
		int myage;
		protected int age;
		protected String name;
		protected int weight;
		static int total = 0;//静态变量\类变量,属于大家的,类下的所有实例共有的变量,也可以被任何实例访问
		// 添加一个构造方法,方便实例化;
		public Cat(int age, String name) {
			System.out.println("我是构造函数");
			this.add();
			this.name = name;
			this.age = age;
		}

		public Cat() {
			this.add();
		}
		public void add(){
			total ++;
			System.out.println("加入一只新猫");
			System.out.println("目前猫的总数是:" + total);
		}
		// 成员方法
		public void jump() {
			System.out.println("我是猫,我会跳");
		}

		// 猫会计算
		public int count(int a) {
			int b = 0;
			for (int i = 1; i < a + 1; i++) {
				b += i;
				System.out.println(i);
			}
			return b;

		}
		public static int mytotal (){
			return total;
		}

		// 猫还会更复杂的计算
		public int count(int a, int b) {
			int c = 0;
			for (int i = a; i < b + 1; i++) {
				c += i;
			}
			return c;
		}

		public void juju(int a) {
			// 打印九九乘法表
			for (int i = 1; i < a + 1; i++) {
				for (int j = 1; j < a + 1; j++) {
					System.out.print(j + "*" + i + "=" + i * j);
					if ((i * j + "").length() > 1) {
						System.out.print("   ");
					} else {
						System.out.print("    ");
					}

					if (j == i) {
						System.out.println();
						break;
					}
				}
			}
		}

		public void zhangzi(int mys[][]) {// 转置
			for (int i = 0; i < mys.length; i++) {
				for (int j = 0; j < mys[0].length; j++) {
					System.out.print(mys[i][j] + " ");
				}
				System.out.println();
			}
			for (int i = 0; i < mys.length; i++) {
				for (int j = 0; j < mys[0].length; j++) {
					if (j > i) {
						int a = mys[i][j];
						mys[i][j] = mys[j][i];
						mys[j][i] = a;
					}

					// System.out.print(mys[i][j] + " ");
				}
				// System.out.println();
			}
			for (int i = 0; i < mys.length; i++) {
				for (int j = 0; j < mys[0].length; j++) {
					System.out.print(mys[i][j] + " ");
				}
				System.out.println();
			}

		}
	}
	public static class dog {//当一个类被定义时,就会把变量和方法存入到代码区,实例化时只执行相应的构造函数
		static int i = 1;
		//静态区域块,只执行一次
//		static {
//			i++;
//		}
		public dog (){
			i ++;
		}
		
	}
	class Clerk{
		public String name;
		private int age;
		private float sal;
		public Clerk (String name, int age, float sal){
			this.name = name;
			this.sal = sal;
			this.age = age;
			
		}
		public float getsal (){
			return sal;
		}
	}
}