Java学习笔记——面向对象基础、构造方法

面向对象

1. 面向对象
2. 面向过程
3. 类的创建
4. 对象的创建
5. 对象创建内存分析
6. 构造方法
7. this关键字

第一节 ： 面向对象的设计思想

1.1 什么是面向对象

一种看待问题的思维方式，着眼于找到一个具有特殊功能的具体个体，然后委托这个个体去做某件事情，我们把这个个体就叫做对象。
是一种更符合人类思考习惯的思想【懒人思想】，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者
使用面向对象进行开发，先要去找具有所需功能的对象来用，如果该对象不存在，那么创建一个具有所需功能的对象

1.2 面向过程

一种看待问题的思维方式，在思考问题的时候，着眼于问题是怎样一步一步解决的，然后按照步骤去解决问题。

1.3 面向对象和面向过程的对比

面向对象是基于万物皆对象这个哲学观点

举例说明：

案例一：我想要吃大盘鸡

面向过程                            面向对象

1.自己去买菜                     1.委托一个会砍价的人帮忙去买菜

2.自己择菜                      2.委托一个临时工帮忙择菜

3.自己做菜                      3.委托一个厨师帮忙做菜

4.自己开始吃                     4.自己开始吃

案例二：小明是一个电脑小白，想要配一台电脑，买完零件后需要运到家里，组装完成后打开电脑玩游戏

面向过程                           面向对象

1.小明补充电脑知识              1.委托一个懂电脑的朋友(老王)去帮忙买零件

2.小明去买零件                    2.委托一个快递小哥帮小明送到家里

3.小明把零件带回家里                 3.委托一个会组装电脑的人帮小明组装电脑

4.小明组装电脑                4.小明自己打开电脑，开始玩游戏

5.小明开机玩电脑                  

1.4 区别总结

a.都是看待问题的一种思维方式，都能解决问题
b.面向过程着眼于所有的事情按照步骤来实现
c.面向对象着眼于找到一个具有特殊功能的对象，委托这个对象去做某件事情
注意：面向对象是一种思想，并不是一门编程语言

1.5 类的概念

具有相同属性和功能的实体的集合[群体]，类是Java语言的最基本单位

1.6 对象的概念

在一个类中，一个具有特殊功能的实体，能够解决特定的问题，对象也被称为实例

1.7 类与对象之间的关系

类是对象的抽象（模板）,对象是类的具体体现(实例)

1.8 类的声明

语法：访问权限修饰符 class 类名 {

                //属性

                //方法

        }

说明：a.访问权限修饰符：只能是public(可以被省略，省略后为default)

        b.类名只要是一个合法的标识符即可，但是要求：首字母必须大写，遵循帕斯卡命名法

        c.尽量使用单个或多个有意义的单词连接而成



         public class  Student{

            //属性

            //方法

         }

注意：a.一个Java文件中可以写多个类，如果写多个类，则编译后会生成多个.class文件

            b.一个Java文件中最多只能有一个被public修饰的类，这个类的类名必须和Java源文件名保持一致

        c.一个Java文件中如果只有一个类，并且这个类不用public修饰的话，类名和文件名可以不一样，但习惯上，我们都会写上public

1.9 类中成员变量的定义

成员变量：

    a.成员变量也被称为属性

    b.分为静态成员变量和非静态成员变量

    c.在静态方法中只能访问静态成员变量，在非静态方法中可以访问非静态成员变量和静态成员变量

成员变量和局部变量的区别：

a.定义的位置不同

        成员变量：定义于类中，作用于整个类

        局部变量：定义于方法或者语句中，作用于该方法或者该语句。

b.内存中出现的时间和位置不同

        成员变量：当对象被创建时，出现在堆内存当中。

        局部变量：所属的方法被运算时，出现在栈内存当中。

c.生命周期不同

        成员变量：随着对象的出现而出现，随着对象的消失而消失。

        局部变量：随着所属方法运算结束，它就被释放。

d.初始化值不同

        成员变量：成员变量因为在堆内存当中，所以他有默认的初始值

        局部变量：没有默认的初始值

e. 成员变量和局部变量名字相同，局部变量优先级高。就近原则。

1.10 类中方法的定义

a.分为静态方法和非静态方法

b.在同一个类中，在静态方法中只能调用静态方法，在非静态方法中可以调用非静态方法和静态方法

/**
 * 人类:描述人    静态特征: 姓名  性别  身高   体重  ....   动态特征： 吃  喝   写代码  睡觉   谈恋爱...
 *  成员变量  ： 描述静态特征
 *  方法： 描述动态特征
 *  
 * @author wgy
 * public  访问修饰符  公开的
 * class   表示类 
 * Person  类名 
 *
 */
public class Person {
    //成员变量
    String  name;//姓名
    String sex;//性别
    int height;//身高
    int weight;//体重

    //方法
    //吃
    public void  eat() {
        System.out.println(name+" 吃饭....");
    }
    //喝
    public void drink() {
        System.out.println(name+" 喝啤酒");
    }
    //写代码
    public void writeCode() {
        System.out.println(name+" 写java代码");
    }

}

第二节：对象的创建以及内存分析

2.1 对象的创建

对象的创建过程也被称为对象的实例化过程

语法：类名 标识符 = new 类名();

//演示对象的创建，跨类进行调用成员方法以及访问成员变量
//测试类：含有main函数得类被称为测试类
public class TestPerson 
{
    public static void main(String[] args) 
    {
        //1.创建对象
        //语法:类名 变量名称  = new  类名();
        Person xiaoMing = new Person();

        //2.调用对象属性
        //语法：对象.属性名
        xiaoMing.name = "小明";
        xiaoMing.age = 10;
        xiaoMing.gender = 'B';
        //3.调用对象方法
        //语法：对象.方法名()
        xiaoMing.eat();
    }
}

//实体类：表示具有某些特征或者某些行为的类
//描述多个对象所具有的共同特征和共同行为
//需求：人类，具有姓名，年龄，性别等的特征，可以吃东西，可以奔跑，，，，
class Person
{
    //第一部分
    //成员变量：特征【名词】
    //非静态成员变量
    String name;//null
    int age;//0
    char gender;//\u0000

    //第二部分
    //成员方法：行为【动词】
    //非静态成员方法
    public void eat() {
        System.out.println("eating~~~~");
    }
}

2.2 JVM内存分配

程序运行时，操作系统会分配三块主要的内存空间

• 栈：直接存放基本类型数据，和引用类型的地址
  
  • 栈空间比较小，存取速度相对较快
  • 先进后出
• 堆：存放引用类型的实际数据部分
  
  • 堆空间比较大，存取速度相对较慢

• 方法区：（静态区、串池(常量池)、代码段)，方法区中有一块空间叫串池，用来存放字符串常量，
  在jdk1.8之后常量池作为堆中一部分，方法区的概念弱化。元空间
  2.3 内存分析

  说明：程序中定义的Person类型的变量实际上是一个引用，它被存放在栈内存中，他指向实际的Person对象，而真正的Person对象则存放于堆内存中

2.4 练习

//测试类
public class Test 
{
    public static void main(String[] args) 
    {
        //需求：开学了，王老师让学生小明，小花，小丽做自我介绍
        //姓名，年龄，爱好，来一段才艺展示
        /*
        老师类
        特征：姓名
        行为：让学生做自我介绍
        */
        //1.创建一个老师的对象
        Teacher wang  = new Teacher();
        wang.name = "王老师";
        wang.letStuIntroduce();
    }
}

//老师类
public class Teacher
{
    String name;

    //让学生自我介绍
    public void letStuIntroduce() {

        Student stu=new Student();
         stu.name = "小明";
        stu.age = 10;
        stu.hobby = "敲代码";
        stu.introduce();
        stu.dance();
         stu.sing();

    }
}

//学生类
public class Student
{
    String name;
    int age;
    String hobby;

    public void introduce() {
        System.out.println("我是" + name + "今年" +  age + "爱好：" + hobby);
    }

    public void dance() {
        System.out.println("跳一段广场舞");
    }

    public void sing() {
        System.out.println("来一段freeStyle");
    }
}

第三节：构造方法的定义

3.1 构造方法的定义

构造方法也叫构造器，是指当实例化一个对象（创建一个对象）的时候，第一个被调用的方法

语法：

访问权限修饰符 类名(参数列表) {
    //方法体
}

普通方法：

访问权限修饰符 其他的修饰符 返回值类型 方法名（参数列表） {

}

注意：a.构造方法没有返回值类型,构造方法是在实例化对象的过程中自动调用的

                b.如果不写构造方法，系统会默认为我们提供一个无参的构造方法，如果添加了构造方法，系统不再提供默认的构造方法。

3.2 构造方法的调用

//演示构造方法的使用
public class Test 
{
    public static void main(String[] args) 
    {
        //创建动物
        Animal dog=new Animal();
        //使用属性
        dog.color="黄色";
        dog.nickname="旺财";
        dog.age=3;
        //使用方法
        dog.eat();
    }
}

public class Animal {
    //颜色
    String color;
    //昵称
    String nickname;
    //年龄
    int age;
    //默认构造方法
    public Animal() {

    }

    //吃
    public void eat() {
        System.out.println(nickname+"大口大口吃东西");
    }
}

3.3 构造方法和普通方法的区别

a.构造方法是在创建对象的过程中自动调用的，普通方法只能手动进行调用

b.构造方法没有返回值类型【注意区别返回值void】，普通方法的返回值类型要么是确定的类型，要么为void

c.系统会默认为我们提供一个无参的构造方法,普通方法只能手动添加

d.构造方法的方法名称必须和对应的类名保持一致

e.构造方法在创建对象的过程中就会执行，而且每个对象都执行一次，对于普通方法而言，只有在需要使用的时候才被执行，并且一个对象可以调用多次

3.4 构造方法重载

方法重载：同一个类中，方法名相同，参数类别不同

     参数列表不同：个数不同，类型不同，顺序不同

     和返回值修饰符无关

默认构造方法：只能创建对象，不能做任何初始化操作，如果实现创建对象时初始化属性，需要添加带参的构造方法，初始化对象的属性。如果一个类中有多个构造方法，这就是构造方法重载。

//演示构造方法的重载
//测试类
public class Test 
{
    public static void main(String[] args) 
    {
        //直接赋值
        /*
        Dog maomao = new Dog();
        maomao.name = "毛毛";
        maomao.age = 3;

        maomao.lookHome();
        */

        //通过构造方法赋值
        Dog dahuang = new Dog("大黄",5);
        dahuang.lookHome();
    }
}

//实体类
public class Dog
{
    //成员变量
    String name;
    int age;

    //构造方法
    public Dog() {}
    //有参的构造方法，参数一般设置为和成员变量有关的参数
    public Dog(String n,int a) {
        //给成员变量赋值
        name = n;
        age = a;
    }
    /*
    public Dog(String n) {
        name = n;
    }
    */

    //成员方法
    public void lookHome() {
        System.out.println(name + "看家");
    }
}

3.5 练习

//测试类
public class Test 
{
    public static void main(String[] args) 
    {
        //场景：富二代王思聪开着新买的白色宝马在马路上奔跑，很自豪的向他的新女友炫耀
        /*
        富二代类
        特征：姓名  钱
        行为：开车，炫耀

        汽车类
        特征：颜色，品牌
        行为：奔跑

        女友类
        特征:姓名
        */
        //1.创建一个富二代的对象
        RichMan wang = new RichMan("王思聪",50000000);


        wang.drive();
        wang.show();
    }
}

/*
富二代类
        特征：姓名  有钱
        行为：开车，炫耀车
*/
public class RichMan
{
    //成员变量
    String name;
    double money;

    //默认构造方法
    public RichMan() {

    }
    //带参构造方法
    public RichMan(String n,double m) {
        name = n;
        money = m;
    }

    //成员方法
    public void drive() {
        Car c=new Car();
        c.brand="宝马";
        System.out.println(name + "开着豪车" + c.brand);
    }
    //展示
    public void show() {
        Car c=new Car();
        c.brand="宝马";
        GirlFriend gf=new GirlFriend();
        gf.name="凤姐";
        System.out.println(name + "向" + gf.name + "炫耀豪车" + c.brand);
    }
}

/*
汽车类
        特征：颜色，品牌
        行为：奔跑
*/
public class Car
{
    //成员变量
    String color;
    String brand;

    //构造方法
    public Car() {}
    public Car(String c,String b) {
        color = c;
        brand = b;
    }

    //成员方法
    public void run() {
        System.out.println("一辆" + color + "的" + brand + "在奔跑");
    }
}

/*
女友类
        特征:姓名
*/
public class GirlFriend
{
    //成员变量
    String name;

    //构造方法
    public GirlFriend(){}
    public GirlFriend(String n) {
        name = n;
    }
}

第四节：this关键字

this：表示当前对象的引用。

4.1 this.属性

访问本类的成员属性

作用：为了区分成员变量和形参变量名一样的情况

成员变量默认值:

引用类型：null

基本类型：byte short int ：0

               long : 0L

       float: 0.0f

       double:0.0

           char :0

       boolean:false

4.2 this.方法

访问本类的成员方法

4.3 练习

//演示this的使用
public class Test 
{
    public static void main(String[] args) 
    {
        //
        Cat maomao = new Cat("毛毛",10);
        maomao.show1();


    }
}

public class Cat
{
    String name;//昵称
    int age;//年龄
    String color;//颜色
    public Cat() {
        System.out.println("无参的构造方法被调用");
    }
    //1.this.属性
    public Cat(String name,int age,String color) {
        this.color = color;
        this.name=name;
         this.age=age;
        System.out.println("带参2构造方法被调用");
    }



    //2.this.方法
    //普通方法
    public void show1() {
        //在本类中调用方法时，this可以省略
        this.show2();
    }

    public void show2() {
        System.out.println("昵称:"+name+" 颜色:"+color+" 年龄:"+age);
    }
}

4.4 this()（了解）

访问本类中的其他构造方法

注意：

    a.必须出现在构造方法中

    b.访问的是除了当前构造方法之外的其他构造方法

    c.具体访问的是哪个构造方法，取决于所传的参数

    d.只能书写在构造方法的第一条语句

    e.this()在同一个构造方法中只能出现一次

public class Test 
{
    public static void main(String[] args) 
    {
        System.out.println("Hello World!");
    }
}
public class Dog
{
     String name;
     int age;
     int num;
     String hobby;

    //提高代码的可读性，可维护性
    //构造方法
    public Dog() {
    }
    public Dog(String name) {
        this.name = name;
    }
    public Dog(int age) {
        this.age = age;
    }

    public Dog(String name,int age) {
        this.name = name;
        this.age = age;
    }
    public Dog(String name,int age,int num,String hobby) {
        this(name,age);
        this.num= num;
        this.hobby = hobby;
    }
}

总结

1 面向对象思想: 一种思维方式，着眼于找到一个具有特殊功能的具体个体，然后委托这个个体去做某件事情。

面向过程思想：一种思维方式，着眼于解决问题的过程和步骤。

2 类的概念 ： 具有特殊功能的实体的集合[群体]

3 对象：一个具体特殊功能的实体。

4 类和对象的关系：类是对象的抽象或模板，对象是类的具体或实例

5 定义类

public   class  Person{

    //成员变量  属性

    //方法

}

6 创建对象

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

//使用对象的属性和方法

对象名.属性名

对象名.方法名();

  对象的内存分配

  栈

 堆

方法区 ( 静态区，串池(常量池), 代码段)   

7 构造方法：创建对象时调用的方法。

public  类名(){

    }   

默认构造方法

带参构造方法

    构造方法重载 

8 this关键字 ：表示当前对象的引用

this.属性

this.方法

this();//调用其他的构造方法

面试题

1.什么是面向对象？面向对象和面向过程的区别是什么

• 面向对象是一种看待问题的思维方式，着眼于找到一个具有特殊功能的具体个体，然后委托这个个体去做某件事情，我们把这个个体就叫做对象。
  是一种更符合人类思考习惯的思想【懒人思想】，可以将复杂的事情简单化，将程序员从执行者转换成了指挥者

• 区别：
  a.都是看待问题的一种思维方式，都能解决问题
  b.面向过程着眼于所有的事情按照步骤来实现
  c.面向对象着眼于找到一个具有特殊功能的对象，委托这个对象去做某件

2.构造方法与普通方法之间的区别

• 构造方法在初始化类的对象时调用，作用是初始化类中的数据； 普通方法通过 对象.方法 调用，目的是为了完成一些特定的功能。

3.this关键字的作用以及使用

• this 表示当前对象，使用 this.属性/方法 表示调用当前对象的方法或属性； this(参数) ;表示调用本类的构造方法，其必须放在第一行。