java基础面向对象

面向对象

什么是对象

1. 从java的角度: “万物皆对象”.对象是一个操作单位, 所有内容都可以被认定为是一个对象(一个操作单位)
2. 从程序的角度: 对象是内存中的一块存储空间, 存放着现实生活中对象特征和行为的具体信息

对象的组成

1. 特征：都有什么
2. 行为：都会什么

对象间的关系

1. is a: 一个对象继承自另一个对象

   • 狗是一个动物 Dog is a Animal
   • 猫是一个动物 Cat is a Animal

2. has a: 一个对象是另一个对象的组成部分

   • 键盘是一个对象
   • 屏幕是一个对象
   • 电脑是一个对象
   • 电脑包含键盘和屏幕

3. use a: 一个对象使用另一个对象

   • 电脑是一个对象
   • 程序员是一个对象
   • 程序员使用电脑

类的组成

1. 属性：描述对象特征，也称为全局变量|成员变量|成员属性等

数据类型 属性名=值；
数据类型  属性名；  更常用

• 位置: 类以内,其他内容以外, 通常写在类的最上方

• 特点: 有默认值,作用为空间占位,保证会分配空间

• 属性和局部变量的区别:

  	局部变量	属性
  位置	方法内部	方法外部
  默认值	没有	有
  作用范围	定义行开始至直属代码块结束	至少整个类
  命名冲突	同一作用范围内不可重名	可以与局部变量重名,局部变量优先级更高

2. 方法 : 描述对象行为. 也称为成员方法|普通方法等

函数就是加了static的方法

访问修饰符 返回值类型 方法名(形参列表){
    //操作语句
    //return 语句;
}

• 位置: 类以内,方法以外,和属性平级

package com.by.entity;

public class Student {
    String name;
    int age;
    String sex;
    double score;
   // score=90.0; 错误!!
    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }
    //睡觉
    public void sleep(){
        System.out.println("睡觉");
    }
    //学习
    public void study(){
        System.out.println("学习");
    }

}

创建对象

 类名 对象名=new 类名();

对象的使用

1. 使用属性

取值:对象名.属性名;
赋值:对象名.属性名=值;

2. 使用方法

对象名.方法名（实参列表）

//创建一个学生对象
        Student stu1 = new Student();
        Student stu2 = new Student();
        //给stu1对象属性赋值
        stu1.name = "zhangsan";
        stu1.age = 20;
        stu1.sex = "男";
        stu1.score = 90;
        //获取stu1对象属性的值
        System.out.println(stu1.name);
        System.out.println(stu1.age);
        System.out.println(stu1.sex);
        System.out.println(stu1.score);
        //获取查看stu2属性的值
        System.out.println(stu2.name);
        System.out.println(stu2.age);
        System.out.println(stu2.sex);
        System.out.println(stu2.score);

        //调用stu1中的方法
        stu1.eat();
        stu1.sleep();
        stu1.study();

构造方法

• 特殊的方法，作用为创建对象

语法

1. 无参构造

访问修饰符 类名（）{
}

2. 有参构造

访问修饰符 类名(数据类型 参数名1,数据类型 参数名2,..){
    属性名1=参数名1;
    属性名2=参数名2;
    ..
}

package com.by.entity;

public class Student {
    public String name;
    public int age;
    public String sex;
    public double score;
   // score=90.0; 错误!!

    //无参构造
    public Student() {

    }
    //有参构造
    public Student(String n, int a, String s, double sc){
        //用对应形参给对应属性赋值
        name = n;
        age = a;
        sex = s;
        score = sc;
    }

    //吃饭
    public void eat(){
        System.out.println("吃饭");
    }
    //睡觉
    public void sleep(){
        System.out.println("睡觉");
    }
    //学习
    public void study(){
        System.out.println("学习");
    }

}

特点

1. 语法特点:

   • 没有返回值类型部分
   • 方法名必须与类名一致

2. 使用特点:

   • 构造方法只能创建对象,创建对象也只能使用构造

   • 创建对象的语法延伸:

     类名 对象名=new 类名();
     

     • 第一个类名: 用来声明创建的是哪个类的对象
     • 第二个类名: 用来指明调用构造方法

   • 构造方法必须通过new关键字调用

   • 根据创建对象时的小括号内的参数列表决定调用的是哪个构造

   • 语法补充: 利用有参构造创建对象

     类名 对象名=new 类名(实参列表);
     

     //利用有参构造创建一个学生对象
     Student stu = new Student("zhangsan", 20, "男", 100.0);
     

   • 无参构造与有参构造的区别:

     1. 无参构造: 只负责创建对象
     2. 有参构造: 在创建对象的同时可以给属性赋初始值
     3. 无参构造至多存在一个,有参构造可以存在0-n个

   • 每个类中都会默认提供一个无参构造, 该构造具有时效性,当类中显式定义构造后,默认给予的构造将会失效

对象包含案例代码:

package com.by.entity;

/**
 * 班级类
 */
public class Clazz {
    public String className;
    public int classNumber;
    //添加一个老师对象属性
    public Teacher tea;

    //无参构造
    public Clazz(){

    }

    //有参构造
    public Clazz(String cName, int cNumber) {
        className = cName;
        classNumber = cNumber;
    }

}
/**
 * 老师类
 */
public class Teacher {
    public String name;
    public String sex;

    public Teacher(){

    }
    //有参构造
    public Teacher(String n,String s){
        name = n;
        sex = s;
    }
    //行为方法-教学
    public void teach(){
        System.out.println("正在教java...");
    }

}

package com.by.test;

import com.by.entity.Clazz;
import com.by.entity.Teacher;

public class Test3 {
    public static void main(String[] args) {
        //创建一个老师对象
        Teacher t = new Teacher("张三", "男");
        //创建一个班级对象
        Clazz c = new Clazz("1班", 20);
        //将对象t赋值给c的tea属性
        c.tea = t;
        //查看班级对象c的所有信息: 班级名  班级人数 所包含的老师姓名  所包含的老师性别
        System.out.println("班级名: "+c.className+
                "  班级人数:"+c.classNumber+
                "  所包含的老师姓名:"+c.tea.name+
                "  所包含的老师性别:"+c.tea.sex);

    }
}

方法重载

作用

为了方便程序员书写和调用功能相同或相似的方法

规则

1. 方法名必须相同
2. 参数列表必须不同
3. 与访问修饰符,返回值类型,异常没有关系

this关键字

• 代表当前对象

this.

this.属性名: 用来指明当前类的属性
this.方法名(实参列表):用来指明调用当前类的方法

有参构造标准语法

public  类名(数据类型 属性名1,数据类型 属性名2,..){
this.属性名1=属性名1;
this.属性名2=属性名2;
...
}

this()

• 作用为调用本类的其他构造内容

使用

1. 根据实参列表决定调用的是哪个构造内容
2. 必须写在构造方法有效代码第一行
3. 无法循环调用

 	public Student() {
     //this();循环调用,错误!
        this("lisi", 20, "男", 90.0);
    }
    //有参构造
    public Student(String name, int age, String sex, double score){//name="张三"  age=22  sex="男"  score=90.5
        //用对应形参给对应属性赋值
        this(name, age);
        this.sex = sex;
        this.score = score;
    }

    public Student(String name, int age) {
        //this(); 循环调用,错误!
        this.name = name;
        this.age = age;
    }

对象创建过程

• 又名属性的三个赋值时期

1. 开辟空间,赋默认值
2. 赋初始值
3. 执行构造时再次赋值