Java基础 --- 面向对象

面向对象


面向对象介绍


介绍

  • 面向:拿、找
  • 对象:能干活的东西
  • 面向对象编程:拿东西过来坐对应的事情

设计对象并使用


类和对象

  • 类(设计图):是对象共同特征的描述;
  • 对象:是真实存在的具体东西

在Java中,必须先设计类,才能获得对象。


如何定义类

public class 类名{
    1.成员变量(代表属性,一般是名词)
    2.成员方法(代表行为,一般是动词)
    3.构造器(后面学习)
    4.代码块(后面学习)
    5.内部类(后面学习)
}

public class Phone {
    String brand;
    double print;
    //行为(方法)
    public void call(){
        
    }
    public void playGame(){
        
    }
}

如何得到类的对象

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

如何使用对象

  • 访问属性:对象名.成员变量
  • 访问行为:对象名.方法名(...)

范例:

public class Phone {
    //属性
    String brand;//手机的品牌
    double price;//手机的价格
    //行为
    public void call(){
        System.out.println("手机在打电话");
    }
    public void playGame(){
        System.out.println("手机在玩游戏");
    }
}

public class PhoneTest {
    public static void main(String[] args) {
        //创建手机的对象
        Phone p = new Phone();
        //给手机赋值
        p.brand = "菠萝";
        p.price = 1145.14;
        //获取手机对象中的值
        System.out.println(p.brand);
        System.out.println(p.price);
        //调用手机中的方法
        p.call();
        p.playGame();

        //第二部手机
        Phone p2 = new Phone();
        p2.brand = "鸭梨";
        p2.price = 1008.6;

        p2.call();
        p2.playGame();
    }
}

总结

  1. 类和对象是什么?

    • 类:是对象共同特征的描述(设计图);对象:是真实存在的具体实例。
  2. 如何得到对象?

    public class 类名{
        1.成员变量(代表属性,一般是名词)
        2.成员方法(代表行为,一般是动词)
    }
    
    类名 对象名 = new 类名();
    
  3. 拿到对象后能做什么?

    • 对象名.成员变量
    • 对象名.方法名(...)

类的几个补充注意事项


  • 用来描述一类事物的类,专业叫做: Javabean类

    在Javabean类中,是不写main方法的。

  • 在以前,编写main方法的类,叫做测试类

    我们可以在测试类中创建javabean类的对象并进行赋值调用。

public class 类名{
    1.成员变量(代表属性)
    2.成员方法(代表行为)
}
  • 类名首字母建议大写,需要见名知意,驼峰模式。

  • 一个Java文件中可以定义多个class类,且只能一 个类是public修饰,而且public修饰的类名必须成为代码文件名。

    实际开发中建议还是一个文件定义一个class类。

  • 成员变量的完整定义格式是: 修饰符 数据类型 变量名称 = 初始化值;一般无需指定初始化值,存在默认值。

    数据类型 明细 默认值
    基本类型 byte、short、int、long 0
    基本类型 float、double 0.0
    基本类型 boolean false
    引用类型 类、接口、数组、String null

练习


女朋友类

编写女朋友类,创建女朋友类的对象

给女朋友的属性赋值并调用女朋友类中的方法。

自己思考,女朋友类中有哪些属性,有哪些行为?

public class GirlFriendTest {
    public static void main(String[] args) {
        //创建女朋友的对象
        GirlFriend gf1 = new GirlFriend();
        gf1.name = "柳如烟";
        gf1.age = 18;
        gf1.gender = "女神";

        System.out.println(gf1.name);
        System.out.println(gf1.age);
        System.out.println(gf1.gender);

        gf1.sleep();
        gf1.eat();

        System.out.println("=====================================");

        GirlFriend gf2 = new GirlFriend();
        gf2.name = "苏沐雪";
        gf2.age = 19;
        gf2.gender = "青梅竹马";

        System.out.println(gf2.name);
        System.out.println(gf2.age);
        System.out.println(gf2.gender);

        gf2.sleep();
        gf2.eat();
    }
}

总结

  1. 定义类有哪些建议,有什么需要注意的?

    • 类名首字母建议大写、英文、有意义,满足驼峰模式,不能用关键字,满足标志符规定;

    • 一个代码文件中可以定义多个类,但是只能一个类是public修饰的,

      public修饰的类名必须是Java代码的文件名称。

  2. 成员变量的格式是什么样的,有什么特点?

    • 成员变量的完整定义格式是:修饰符 数据类型 变量名称 = 初始化值;
    • 一般无需指定初始化值。

封装


告诉我们,如何正确设计对象的属性和方法

原则:对象代表什么,就得封装对应的数据,并提供数据对应的行为


封装的好处

  • 让编程变得很简单,有什么事,找对象,调方法就行。
  • 降低我们的学习成本,可以少学、少记,或者说压根不用学,不用记对象有哪些方法,有需要时去找就行

private关键字

  • 是一个权限修饰符
  • 可以修饰成员(成员变量和成员方法)
  • private修饰的成员只能在本类中才能访问
public class GirlFriend {
    private String name;
    private int age;
    private String gender;

    //针对于每个私有化的成员变量,都要提供get和set方法
    //set方法:给成员变量赋值
    //get方法;对外提供成员变量的值

    public void setName(String n){
        name = n;
    }
    public String getName(){
        return name;
    }

    public void setAge(int a){
        if(a >= 0 && a <= 100){
            age = a;
        }else {
            System.out.println("非法参数");
        }
    }
    public int getAge(){
        return age;
    }

    public void setGender(String g){
        gender = g;
    }
    public String getGender(){
        return gender;
    }

    //行为
    public void sleep(){
        System.out.println("女朋友在睡觉");
    }
    public void eat(){
        System.out.println("女朋友在吃饭");
    }
}

public class GirlFriendTest {
    public static void main(String[] args) {
        GirlFriend gf1 = new GirlFriend();
        gf1.setName("柳如烟");
        gf1.setAge(18);
        gf1.setGender("女");

        System.out.println(gf1.getName());
        System.out.println(gf1.getAge());
        System.out.println(gf1.getGender());

        gf1.sleep();
        gf1.eat();
    }
}

总结

  1. private关键字是一个权限修饰符
  2. 可以修饰成员(成员变量和成员方法)
  3. 被private修饰的成员只能在本类中才能访问
  4. 针对private修饰的成员变量,如果需要被其他类使用,提供相应的操作
  5. 提供“setxxx(参数)”方法,用于给成员变量赋值,方法用public修饰
  6. 提供"getxxx()"方法,用于获取成员变量的值,方法用public修饰

就近原则和this关键字


就近原则

  • 谁离我近我就用谁

成员变量和局部变量

public class GirlFriend{
    private int age;//成员变量
    public void method(){
        int age = 10;//局部变量
        System.out.println(age);//打印局部变量
    }
}

public class GirlFriend{
    private int age;//成员变量
    public void method(){
        int age = 10;//局部变量
        System.out.println(this.age);//打印成员变量
    }
}

范例:

public class GirlFriend {
    private String name;
    private int age;
    private String gender;

    //针对于每个私有化的成员变量,都要提供get和set方法
    //set方法:给成员变量赋值
    //get方法;对外提供成员变量的值

    //作用:给成员变量name进行赋值的·
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }
    public void setAge(int age){
        if(age >= 0 && age <= 100){
            this.age = age;
        }else {
            System.out.println("非法参数");
        }
    }
    public int getAge(){
        return age;
    }

    public void setGender(String gender){
        this.gender = gender;
    }
    public String getGender(){
        return gender;
    }

    //行为
    public void sleep(){
        System.out.println("女朋友在睡觉");
    }
    public void eat(){
        System.out.println("女朋友在吃饭");
    }
}

public class GirlFriendTest {
    public static void main(String[] args) {
        GirlFriend gf1 = new GirlFriend();
        gf1.setName("柳如烟");
        gf1.setAge(18);
        gf1.setGender("女");

        System.out.println(gf1.getName());
        System.out.println(gf1.getAge());
        System.out.println(gf1.getGender());

        gf1.sleep();
        gf1.eat();
    }
}

总结

  1. 就近原则
  2. this作用:区别成员变量和局部变量
  3. this的本质和内存图

构造方法


概述:

  • 构造方法也叫做构造器、构造函数。
  • 作用:在创建对象的时候给成员变量进行赋值的。

格式:

public class Student{
    修饰符 类名(参数){
        方法体;
    }
}

特点:

  1. 方法名和类名相同,大小写也要一致
  2. 没有返回值类型,练void都没有
  3. 没有具体的返回值(不能有return带回结果数据)

执行时机:

  1. 创建对象的时候有虚拟机调用,不能手动调用构造方法
  2. 每创建一次对象,就会调用一次构造方法

public class Student {
    private String name;
    private int age;

    //如果我们自己没有写任何的构造方法
    //那么虚拟机就会给我们加一个空参构造方法
    public Student (){
        System.out.println("故乡的樱花开了");
    }

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

    public String getName(){
        return name;
    }

    public void setName(String name){
        this.name = name;
    }

    public int getAge(){
        return age;
    }

    public void set(int age){
        this.age = age;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        //创建对象
        //调用的空参构造
        //Student s = new Student();

        Student s = new Student("柳如烟",18);

        System.out.println(s.getName());
        System.out.println(s.getAge());
    }
}

构造方法注意事项

  1. 构造方法的定义
    • 如果没有定义构造方法,系统将给出一个默认无参数构造方法
    • 如果定义了构造方法,系统将不再提供默认的构造方法
  2. 构造方法的重载
    • 带参构造方法,和无参构造方法,两者方法名相同,但是参数不同,这叫做构造方法的重载
  3. 推荐的使用方法
    • 无论是否使用,都手动书写无参构造方法,和带全部参数的构造方法

总结

  1. 构造方法的作用?
    • 创造对象的时候,有虚拟机自动调用,给成员变量进行初始化的。
  2. 构造方法有几种,各自的作用是什么?
    • 无参数构造方法:初始化的对象时,成员变量的数据均采用默认值。
    • 有参数构造方法:在初始化对象的时候,同时可以为对象进行赋值。
  3. 构造方法有哪些注意事项?
    • 任何类定义出来,默认就自带了无参数构造器,写不写都有。
    • 一旦定义有参数构造器,无参数构造器就没有了,此时就需要自己写有参数构造器了。
    • 建议在任何时候都手动写上空参和带全部参数的构造方法。

  • 创造对象的时候,虚拟机会自动调用构造方法,作用是给成员变量进行初始化的。

标准JavaBean


标准JavaBean类

  1. 类名需要见名知意
  2. 成员变量使用private修饰
  3. 提供至少两个构造方法
    • 无参构造方法
    • 带全部参数的构造方法
  4. 成员方法
    • 提供每一个成员变量对应的setXxx()/getXxx()
    • 如果还有其他行为,也要写上

范例:

public class User {
    //属性
    private String username;
    private String password;
    private String email;
    private String gender;
    private int age;
    
    //快捷键:
    //alt + insert
    //alt + Fn + insert
    //插件PTG 1秒生成标准JavaBean(右键空白处,点击倒数第三个)
    
    //空参
    public User(){}
    //带全部参数的构造
    public User(String username,String password,String email,String gender,int age){
        this.username = username;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }
    //get和set方法
    public String getUsername(){
        return username;
    }
    
    public void setUsername(String username){
        this.username = username;
    }
    
    public String getPassword(){
        return password;
    }
    
    public void setPassword(String password){
        this.password = password;
    }
    
    public String getEmail(){
        return email;
    }
    
    public void setEmail(String email){
        this.email = email;
    }
    
    public String getGender(){
        return gender;
    }
    
    public void setGender(String gender){
        this.gender = gender;
    }
    
    public int getAge(){
        return age;
    }
    
    public void setAge(int age){
        this.age = age;
    }
}

对象内存图


一个对象的内存图

Student s = new Student();
  1. 加载class文件
  2. 申明局部变量
  3. 在堆内存中开辟一个空间
  4. 默认初始化
  5. 显示初始化
  6. 构造方法初始化
  7. 将堆内存中的地址值赋值给左边的变量

两个对象的内存图


两个引用指向同意一个对象


基本数据类型和引用数据类型

基本数据类型

  • 在变量当中存储的是真实的数据值

引用数据类型

  • 使用其他空间的数据

从内存的角度去解释:

  • 基本数据类型:数据值是存储在自己的空间中
  • 特点:复制给其他变量,也是赋的真实的值。
  • 引用数据类型:数据值是存储在其他空间中,自己空间中存储的是地址值。
  • 特点:赋值给其他变量,赋的是地址值。

this的内存原理


  • this的作用:区分局部变量和成员变量
  • this的本质:所在方法调用者的地址值

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


成员变量:类中方法外的变量

局部变量:方法中的变量

区别 成员变量 局部变量
类中位置不同 类中,方法外 方法内、方法申明上
初始化值不同 有默认初始化值 没有, 使用之前需要完成赋值
内存位置不同 堆内存 栈内存
生命周期不同 随着对象的创建而存在,随着对象的消失而消失 随着方法的调用而存在, 随着方法的运行结束而消失
作用域 整个类中有效 当前方法中有效

热门相关:美食萌后:皇上,喂不饱!   重生世家子   隐婚365天:江少,高调宠!   文娱缔造者   豪门24小时:吻别霸道前夫