一.面向对象的概述

面向对象：编程使用的一种的编程思想，编程思路
面向对象的特征：封装，继承，多态
对象：万物皆对象，为客观存在的实体事物，看得见摸得着
类:即类型, 对现实生活中一类具有共同属性和行为的事物的抽象和概括其实就是对事物的一种描述
属性即对象具有各种特征
对象行为:对象能够执行的操作
类是对对象的抽象，对象是类的实体
类的定义格式：

[修饰符] class 类名 {

属性:即变量, 成员变量, 对象的属性;

? 行为: 即方法, 对象行为, 对象方法,去掉static关键字

public 返回值数据类型方法名(参数列表){

方法体;

? return 数据;

}

}

对象的定义：使用对象必须依赖于类, 没有类就没有对象
创建对象的格式:

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

类名: 要创建对象的数据类型

=: 将对象在堆区申请内存空间首地址赋值给对象名存储

new: 在堆区申请一块内存空间,并把申请空间首地址赋值给对象名

类名: 和前面的类名一致

()表示调用的是一个方法, 这个方法就是构造方法(构造方法用来创建对象的方法)

对象的使用:

调用属性:

对象名.属性名; (访问属性中的值);

对象名.属性名 = 值;(赋值操作)

调用方法:

对象名.方法名();

代码示例：

public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void study() {
        System.out.println("好好学习，天天向上");
    }

    public void work() {
        System.out.println("努力敲代码中...");
    }
}
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s);
        s.name = "xiaojiang";
        s.age = 20;
        System.out.println(s.name);
        System.out.println(s.age);

        //调用成员方法
        System.out.println(s.name + "-" + s.age);
        s.study();
        System.out.println(s.name + "-" + s.age);
        s.work();
    }
}

二.对象内存图

单个对象:
多个内存图:
多个对象指同一地址:

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

区别	成员变量	局部变量
定义类中的位置不同	类中方法外	类中方法里
空间位置不同	堆内存	栈内存
生命周期不同	随对象存在而存在，随对象消失而消失	随方法调用存在而存在,随方法结束消失而消失
初始化值不同	有默认的初始化值	没有默认初始化值,必须要先定义赋值后使用

三.private关键字

封装概念: 隐藏事物属性的实现细节, 对外公开一个公共方法方式
封装的好处作用:

隐藏实现细节
提高代码的复用性
提高安全性
类封装的原则
隐藏事物的属性
隐藏事物事项细节
提供一个公共的访问方式

private关键字能修饰的内容:

修饰成员变量
修饰成员方法
修饰构造方法
修饰内部类

被private修饰之后, 只能在类的内部直接访问, 但是出了类之后,再类的外部是不能直接访问的
当属性(成员变量)被私有化之后,外界不能直接访问了,所以需要提供公共的访问方式,让外界可以间接的访问成员变量.
属性赋值的公共方式:Setter方法(给成员变量赋值) 属性取值的公共方法:Getter方法(获取成员变量的值)

属性的Setter方法的属性格式:

数据类型属性名

public void set+属性名首字母大写(数据类型参数名){ 参数数据类型和成员变量数据类型一致

? 属性名 = 参数名;

}

如: String name;

public void setName(String n){

name = n;

}

属性的Getter方法格式:

数据类型属性名

public 返回值数据类型 get+属性名首字母大写(){ 返回值数据类型和成员变量数据类型一致

return 属性名;

}

如: String name;

public String getName(){

return name;

}

快速生成方法：鼠标右键找到generate键可以快速生成getter和setter方法

四.构造方法

构造方法是一种特殊的方法，别称构造函数
构造方法的格式:
修饰符(一般为public)方法名称(参数列表){
? 方法体;
}

格式说明:

构造方法的方法名, 必须要类名一模一样,连大小写都要一样

构造方法没有返回值, 连void都不要写

构造方法没有return语句, 如果一定要写return, 就只写一个return;

构造方法不需要手动调用,构造方法是在创建对象的时候由jvm自动调用

不要使用对象名调用构造方法

创建一个对象只调用一次构造方法

3.构造方法的注意事项:

如果没有定义构造方法，系统将给出一个默认的无参构造方法

如果定义了构造方法，系统将不再提供默认的构造方法；如果定义了带参数的构造方法，还要使用无参构造方法，就必须要写一个无参构造方法

构造方法的重载:

重载定义:一个类中,方法名相同,参数列表不同(类型,顺序, 个数),与返回值类型无关,参数名无关

构造方法的名字都和类名相同，只是参数列表不同,没有返回值.则多个构造方法就是方法的重载

代码示例:

public class StudentDemo {
    public static void main(String[] args) {
        //创建无参对象
        Student s = new Student();
        s.show();
        //创建有参对象
        //public Student(String name)
        Student s2 = new Student("xiaojiang");
        s2.show();
        //public Student(int age)
        Student s3 = new Student(20);
        s3.show();
        //public Student (String name,int age)
        Student s4 = new Student("xiaojiang", 20);
        s4.show();
    }
}
public class Student {
    //成员变量
    private String name;
    private int age;

    //无参构造方法
    public Student() {
    }

    //有参构造
    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setxxx()赋值
        Student s1 = new Student();
        s1.setName("xiaojiang");
        s1.setAge(20);
        s1.show();
      //使用带参构造对象直接创建带有属性的对象 通过有参构造来赋值
        Student s2=new Student("xiaojiang",20);
         s2.show();
    }
}
public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法 构造方法必须类名称必须保持一致
    //定义无参构造方法
    public Student() {
        System.out.println("无参构造方法。。。");
    }
    //定义有参构造方法
    public Student(String name, int age) {
        System.out.println("通过有参构造给成员属性赋值。。。");
        this.name = name;
        this.age = age;
    }

    //set/get方法
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

快速生成方法：鼠标右键找到generate键，找到constructor键可快速生成构造方法

五.this关键字

this修饰的变量用于指代成员变量
this关键字是为了解决局部变量隐藏成员变量
this代表所在的类对象的引用
方法被哪个对象调用，this就代表哪个对象

方法的形参如果与成员变量相同，不带this修饰的变量指的是形参

方法的形参如果不与成员变量相同，不带this修饰的变量指的是成员变量

5.this的原理内存图:
在这里插入图片描述

this关键字可以用来访问本类的属性,方法,构造器
访问成员方法的语法格式:this.方法名(参数列表)
访问构造器语法格式:this(参数列表)；注意:只能在构造器使用(即只能在一个构造器中访问另一个构造器)必须放在第一条语句
this不能在类定义的外部使用,直能在类定义的方法中使用

代码案例:

public class Student {
    //成员属性 成员变量
    private String userName;
    private int userAge;

    //无参构造方法
    public Student() {
        // this(21);  this();调用有参构造 注意this();
        // 调用其他构造方法时必须要放在语句第一行
        //System.out.println(" 无参构造方法...");
        //this("xiaojiang",21); this();调用有参构造
        // this("xiaojiang");  this();调用有参构造
    }

    //有参构造方法
    public Student(String userName, int userAge) {
        this.userName = userName;
        this.userAge = userAge;
    }

    public Student(String userName) {
        this.userName = userName;
    }

    public Student(int userAge) {
        this.userAge = userAge;
    }


    //set/get方法
    public void setUserName(String userName) {
        this.userName = userName;
    }

    public void setUserAge(int userAge) {
        this.userAge = userAge;
    }

    public String getUserName() {
        return userName;
    }

    public int getUserAge() {
        return userAge;
    }

    public void a1() {
        System.out.println("方法a1");
        this.a2();//通过this调用到其他方法
    }

    public void a2() {
        System.out.println("方法a2");
    }


    public static void main(String[] args) {
        Student s = new Student();
        s.a1();
    }

}