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

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

一、面向对象：

   1、面向对象是基于面向过程的编程思想
   2、面向对象的思想特点：
      A：是一种更符合我们思考习惯的思想
      B：把复杂的事情简单化
      C：让我们从执行者变成了指挥者

二、类与对象

   1、现实世界的事物
          属性：  事物的基本描述
          行为 ： 事物的功能
   2、Java语言中最基本的单位是类。所以，要用类来体现事物
   3、类
        成员变量 ： 事物属性
        成员方法 ： 事物行为
   4、类：是一组相关的属性和行为的集合。是一个抽象的概念。
         对象：是该类事物的具体存在，是一个具体的实例。(对象)

        Eg：学生--------- 类
                 班长--------- 对象
   5、类的定义及使用
       A：类的定义
            成员变量 定义格式和以前一样，就是位置不同，在类中，方法外。
           构造方法
            成员方法 定义格式和以前一样，就是去掉了static。
      B：使用类的内容
         a：创建对象? 格式
              类名 对象名 = new 类名();
        b：使用成员变量和成员方法：
             对象名：成员变量
             对象名：成员方法()
Eg：

/*
	需求：
		定义一个员工类,自己分析出几个成员，
		然后给出成员变量，构造方法，getXxx()/setXxx()方法，
		以及一个显示所有成员信息的方法。并测试。

	分析：
		员工
			成员变量：
				员工编号，姓名，年龄
			构造方法：
				无参构造方法
			成员方法：
				getXxx()/setXxx()
				show();
*/
class Employee {
	//员工编号
	private String employeeId;
	//姓名
	private String name;
	//年龄
	private int age;
	
	//构造方法
	public Employee() {}
	
	//getXxx()/setXxx()
	public String getEmployeeId() {
		return employeeId;
	}
	
	public void setEmployeeId(String employeeId) {
		this.employeeId = employeeId;
	}
	
	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 show() {
		System.out.println("员工编号是："+employeeId+"的这个人是："+name+"的年龄是："+age);
	}
}

class EmployeeTest {
	public static void main(String[] args) {
		//创建对象
		Employee e = new Employee();
		
		//给成员变量赋值
		e.setEmployeeId("czbk9527");
		e.setName("唐伯虎");
		e.setAge(18);
		
		//获取数据
		//System.out.println(e.getEmployeeId()+"---"+e.getName()+"---"+e.getAge());
	
		//我们在Employee类中定义了一个show方法。所以，我们改进一下，使用show方法
		e.show();
	}
}

   6、Java程序的开发，设计和特征
      A：开发：就是不断的创建对象，通过对象调用功能
        B：设计：就是管理和维护对象间的关系
    C：特征：a：封装
         b：继承
         c：多态

三、代码块

    (1)：用{}括起来的代码
    (2)：分类
          A：局部代码块,方法中，用于限定变量的生命周期,及早释放,提高内存效率
          B：构造代码块 成员位置 类中方法外
                优先于构造方法执行.
               把多个构造方法中相同代码放到这里.
          C：静态代码块,成员位置,
                用static修饰
                特点：随着类的加载而加载
               只执行一次.
                 
              执行顺序:
              静态代码块---构造代码块----构造方法
Eg：

class Code {
	static {
		int a = 1000;
		System.out.println(a);
	}

	//构造代码块
	{
		int x = 100;
		System.out.println(x);
	}
	
	//构造方法
	public Code(){
		System.out.println("code");
	}
	
	//构造方法
	public Code(int a){
		System.out.println("code");
	}
	
	//构造代码块
	{
		int y = 200;
		System.out.println(y);
	}
	
	//静态代码块
	static {
		int b = 2000;
		System.out.println(b);
	}
}

class CodeDemo {
	public static void main(String[] args) {
		//局部代码块
		{
			int x = 10;
			System.out.println(x);
		}
		//找不到符号
		//System.out.println(x);
		{
			int y = 20;
			System.out.println(y);
		}
		System.out.println("---------------");
		
		Code c = new Code();	
		System.out.println("---------------");
		Code c2 = new Code();
		System.out.println("---------------");
		Code c3 = new Code(1);
	}
}

四、继承

        1、把多个类中相同的属性与功能提取到一个独立的类中,然后让其他类与这个独立的类产生关系，这种关系叫继承
        2、java中继承格式
            class 子类名 extends 父类名{}
       3、好处
            A:提高了代码的复用性
            B:提高了代码的维护性
            C:让类与类之间产生关系,多态的前提

           弊端:因为类与类之间产生了继承关系,就高耦合了

          开发的原则:低耦合,高内聚
            耦合:类与类之间的关系
           内聚:一个类完成某件事能力

    4、继承的特点:
        A:只支持单继承,不支持多继承
        B:支持多层继承(继承体系)

    5、注意事项
       A:子类不能继承父类的私有成员(成员变量与成员方法)
       B:子类不能继承父类的构造方法.但是可以调用
       C:不要为了部分功能去继承

    6、什么时候使用继承
             A与B之前存在 A is a B 或者B is a A 的时候
            假设法 class A extends B class B extends A
    7、Java继承中成员的关系
        A:成员变量：
          a：子类中成员变量和父类中成员变量名不一样的时候.
          b：子类中成员变量和父类中成员变量名一样的时候,
                 用的时候采用就近原则
         查找循序：
           子类中的一个方法中
          (1)在子类方法的局部查找
           (2)在子类成员变量查找
          (3)再查看父类的成员变量是否有
         (4)报错
     B：构造方法：
        a：子类的构造方法会默认去访问父类的无参构造
           原因：因为子类要访问父类的数据
       b：如果父类中没有无参构造怎么办?
          (1)：创建一个父类的无参构造
          (2)：子类通过调用super(..)明确调用写好的父类构造
          (3)：子类通过this(..)调用本类的构造,这个本类的构造,必须能够访问写好的父类构造

           特点： this(..)和super(..)只能写在第一句话

     C：成员方法：
        a：子类中的方法与父类中的方法名不一样
        b：子类中的方法与父类中的方法名一样
          查找顺序：(1)：子类查找
                              (2)：再在父类中查找
                              (3)：如果都没有,报错
          重写：子类中出现了与父类中声明(方法名,返回值类型,参数列表)一模一样的方法
          好处：子类可以扩展父类中方法

   8、A：用final修饰的类、变量、方法：
            (1)修饰类：该类不能被继承
            (2)修饰变量：其实相当于定义了一个最终变量(自定义常量),只能赋值一次
            (3)修饰方法：该方法不能被重写.

       B：final初始化时机：
           (1)：被final修饰的变量只能赋值一次
           (2)：非静态的时候,在构造方法完毕前赋上值就可以
           (3)：静态:定义的时候就必须赋值. public static final AI = 12;

     C：局部变量：
        (1)：局部变量是基本数据类型,其数值不能改变,只能赋值一次
        (2)：局部变量是引用数据类型,其对应的地址值不能改变.

Eg：

<span style="font-family:Arial Black;">/*
	猫狗案例：
	先找到具体的事物，然后发现具体的事物有共性，才提取出一个父类。
	
	猫：
		成员变量：姓名，年龄，颜色
		构造方法：无参，带参
		成员方法：
			getXxx()/setXxx()
			eat()
			palyGame()
	狗：
		成员变量：姓名，年龄，颜色
		构造方法：无参，带参
		成员方法：
			getXxx()/setXxx()
			eat()
			lookDoor()
			
	共性：
		成员变量：姓名，年龄，颜色
		构造方法：无参，带参
		成员方法：
			getXxx()/setXxx()
			eat()
			
	把共性定义到一个类中，这个类的名字叫：动物。
	动物类：
		成员变量：姓名，年龄，颜色
		构造方法：无参，带参
		成员方法：
			getXxx()/setXxx()
			eat()
			
		猫：	
			构造方法：无参，带参
			成员方法：palyGame()
		狗：
			构造方法：无参，带参
			成员方法：lookDoor()
*/
//定义动物类
class Animal {
	//姓名
	private String name;
	//年龄
	private int age;
	//颜色
	private String color;
	
	public Animal() {}
	
	public Animal(String name,int age,String color) {
		this.name = name;
		this.age = age;
		this.color = color;
	}
	
	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 String getColor() {
		return color;
	}
	
	public void setColor(String color) {
		this.color = color;
	}
	
	public void eat() {
		System.out.println("不要睡了,该吃饭了");
	}
}

//定义猫类
class Cat extends Animal {
	public Cat() {}
	
	public Cat(String name,int age,String color) {
		super(name,age,color);
	}
	
	public void playGame() {
		System.out.println("猫玩毛线");
	}
}

//定义狗类
class Dog extends Animal {
	public Dog() {}
	
	public Dog(String name,int age,String color) {
		super(name,age,color);
	}
	
	public void lookDoor() {
		System.out.println("狗看家");
	}
}

//测试类
class ExtendsTest5 {
	public static void main(String[] args) {
		//测试猫
		//方式1
		Cat c1 = new Cat();
		c1.setName("Tom");
		c1.setAge(3);
		c1.setColor("白色");
		System.out.println("猫的名字是："+c1.getName()+";年龄是："+c1.getAge()+";颜色是："+c1.getColor());
		c1.eat();
		c1.playGame();
		System.out.println("---------------");
		
		//方式2
		Cat c2 = new Cat("杰瑞",5,"土豪金");
		System.out.println("猫的名字是："+c2.getName()+";年龄是："+c2.getAge()+";颜色是："+c2.getColor());
		c2.eat();
		c2.playGame();
		
		
	}
}

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------