Java基础&面向对象&继承&抽象类

简介: Java基础&面向对象&继承&抽象类

1 面向对象


  • 面向对象的核心思想是什么 ?
  • 用代码来模拟现实生活中的事物 , 比如学生类表示学生事物 , 对象表示的就是具体的学生 , 有了类就可以描述万千世界所有的事物了
  • 现有的类还是先有的对象 ?
  • 对象是根据类创建出来的 , 所有现有的类 , 再有对象
  • Java类的创建 ?

类名建议使用大驼峰命名法 , 每个单词首字母需要大写

Java规定 , 一个Java文件中可以定义多个类 , 但是只能有一个类使用public修饰 , public修饰的类名需要和java文件名保持一致

按照规范 , 实际工作之时 , 建议一个Java文件中只能有一个类


类中的组成成分 ?

  • 1 成员变量
  • 2 成员方法
  • 3 构造方法
  • 4 内部类(后面学)
  • 5 代码块(后面学)

  • 创建对象所使用的关键字 ?
  • new关键字
  • 创建对象的格式 ?
  • 类名 对象名 = new 类名(参数列表);
  • 调用对象的成员 ?
  • 调用成员变量 : 对象名.成员变量名
  • 调用成员方法 : 对象名.成员方法名(参数)
  • 定义构造方法的格式 ?
  • 修饰符 类名(参数){ … }
  • 定义构造方法的特点 ?
  • 没有返回值 , 连void都没有
  • 方法名与类名相同
  • 构造方法可以进行重载定义
  • 构造方法的作用 ?
  • 空参构造 : 初始化对象的数据为默认值
  • 有参构造 : 初始化对象时 , 为对象的属性赋值
  • 面向对象三大特征是什么 ?
  • 封装 , 继承 , 多态
  • 封装的思想及其作用 ?
  • 思想 : 把实现细节隐藏 , 对外提供公共的访问方式
  • 作用 : 提高代码的安全性 , 提高代码的复用性
  • 封装的步骤 ?
  • 把成员变量进行private修饰
  • 提供对应的setter和getter方法
  • this关键字的含义 ?
  • this代表的是本类对象的引用
  • 在构造方法中 , this代表的是new的对象
  • 在成员方法中 , this代表的是调用此方法的对象
  • this关键字的作用 ?
  • 主要用于区分局部变量和成员变量同名的问题


2 匿名对象介绍


  • 什么是匿名对象 ?
  • 没有变量接收的对象 , 称作为匿名对象
  • 匿名对象的使用 ?
  • 直接使用匿名对象调用方法
  • 匿名对象作为方法传参
  • 匿名对象作为方法的返回值
  • 代码实现
/*
    匿名对象 :
        没有对象名接收的对象 , 称作为匿名对象
        有对象名接收的对象 , 称作有名对象

    注意 : 一般使用一次的对象 , 我们可以采用匿名对象

    匿名对象的使用 :
        1 使用匿名对象直接调用方法
        2 使用匿名对象作为方法的传参
        3 使用匿名对象作为方法的返回值
 */
public class Demo1 {
    public static void main(String[] args) {

//        Student s = new Student();
//        s.study();
//        1 使用匿名对象直接调用方法
        new Student().study();


//        Student s2 = new Student();
//        useStudent(s2);
//        2 使用匿名对象作为方法的传参
        useStudent(new Student());
    }

    public static void useStudent(Student s) {
        s.study();
    }

    public static Student getStudent() {
//        Student s = new Student();
//        return s;
        // 3 使用匿名对象作为方法的返回值
        return new Student();
    }
}
class Student {
    public void study() {
        System.out.println("学生学习...");
    }
}
代码实践:注册案例
import java.util.ArrayList;
import java.util.Scanner;

/*
    需求 :
        1 创建用户(User)对象 , 对象数据采用键盘录入而来
        2 用户(User)包含的属性 :
            用户名   (username)
            手机号码 (phonNumber)
            登录密码 (password)
            确认密码 (confirm)
            电子邮箱 (email)
            性别     (sex)
            出生日期 (birthday)
        3 如果登录密码和确认密码不一致 , 重新输入
        4 把用户(User)对象 ,添加到ArrayList集合中 , 打印集合对象即可
 */
public class Demo2 {
    public static void main(String[] args) {
        // 创建集合对象
        ArrayList<User> list = new ArrayList<>();

        // 创建键盘录入对象 , 录入用户的数据
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入用户名:");
        String username = sc.nextLine();
        System.out.println("请输入手机号码:");
        String phoneNumber = sc.nextLine();
        System.out.println("请输入登录密码:");
        String password = sc.nextLine();
        System.out.println("请输入确认密码:");
        // 如果登录密码 , 和确认密码不一致 , 需要重新输入确认密码
        String confirm;
        while (true) {
            confirm = sc.nextLine();
            if (password.equals(confirm)) {
                break;
            } else {
                System.out.println("您输入的登录密码和确认密码不一致, 请重新输入...");
            }
        }
        System.out.println("请输入电子邮箱:");
        String email = sc.nextLine();
        System.out.println("请输入性别:");
        String sex = sc.nextLine();
        System.out.println("请输入出生日期:");
        String birthday = sc.nextLine();

        // 把用户对象添加到集合中
        list.add(new User(username, phoneNumber, password, confirm, email, sex, birthday));

        // 遍历集合
        for (int i = 0; i < list.size(); i++) {
            // 获取集合中的用户对象
            User u = list.get(i);
            System.out.println(u.getUsername() + "---" + u.getPhonNumber() + "---" + u.getPassword() 
            + "---" + u.getConfirm()  + "---" + u.getEmail() + "---" + u.getSex() + "---" + u.getBirthday() );
        }
    }
}
// 用户类
public class User {
    private String username;
    private String phoneNumber;
    private String password;
    private String confirm;
    private String email;
    private String sex;
    private String birthday;

    public User() {
    }

    public User(String username, String phonNumber, String password, String confirm, String email, String sex, String birthday) {
        this.username = username;
        this.phoneNumber = phonNumber;
        this.password = password;
        this.confirm = confirm;
        this.email = email;
        this.sex = sex;
        this.birthday = birthday;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPhonNumber() {
        return phoneNumber;
    }

    public void setPhonNumber(String phonNumber) {
        this.phoneNumber = phonNumber;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getConfirm() {
        return confirm;
    }

    public void setConfirm(String confirm) {
        this.confirm = confirm;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }
}


3 继承


3.1 为什么学习继承 ?


  • 继承是将多个类的相同属性和行为抽取到单独一个类中,那么多个类无需再定义这些共性属性和行为,只要继承这个单独类即可继承这些属性和行为了
  • 多个类称为子类(派生类),单独的这个类称为父类(基类 或超类)


3.2 继承的格式 ?


  • 使用关键字extends进行连接子类与父类
  • 举例 : public class Student extends People{ … }


3.3 继承的好处 ?


  • 提高代码的复用性
  • 提高代码的维护性
  • 让类与类产生了关系(继承关系) , 是多态的前提
/*

    学生类 : 姓名(name) , 课程名称(course) , 所在班级(className)  , 查看课表(lookForm) , 填写反馈数据(write)
    老师类 : 姓名(name) , 课程名称(course) , 部门名称(department) , 查看课表(lookForm) , 发布试题(release)

    设计 : 把学生类 和 老师类的共性内容抽取到一个单独的类中(Person),存储共性内容
    父类 : 姓名(name) , 课程名称(course) ,  查看课表(lookForm)

 */
public class ExtendsDemo1 {
    public static void main(String[] args) {
        Student s = new Student();

        s.setName("张三");
        s.setCourse("Java");
        s.setClassName("三年二班");

        s.lookForm();
        s.write();
    }
}
/*
    此类定义的是子类的共性成员
 */
public class Person {
    private String name;
    private String course;

    public String getName() {
        return name;
    }

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

    public String getCourse() {
        return course;
    }

    public void setCourse(String course) {
        this.course = course;
    }

    public void lookForm(){
        System.out.println("查看课表");
    }

}

/*
    子类只需要定义自己特有的成员 , 共性的成员需要抽取到父类中
 */
public class Student extends Person{
    private String className;

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public void write(){
        System.out.println("填写反馈数据");
    }
}

/*
    子类只需要定义自己特有的成员 , 共性的成员需要抽取到父类中
 */
public class Teacher extends Person {

    private String department;

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public void release() {
        System.out.println("发布试题....");
    }
}

3.5 继承后,子类对象内存图解

3.6 继承的特点


  • Java只支持单继承 , 不支持多继承 , 但是可以多层继承
  • 简单理解 : 一个儿子只能有一个亲爹
  • 为什么不支持多继承 ?

因为一个子类如果继承多个父类 , 父类有相同的方法声明, 子类会产生继承冲突 , 所以不允许


3.7 继承中成员的发访问特点


  • 成员变量

访问特点-就近原则 : 局部有访问局部的 , 局部没有访问本类成员的 , 本类成员没有访问父类非私有成员

  • 成员方法
  • 访问特点-就近原则 : 子类有调用子类的 , 子类没有调用父类的
  • 构造方法
  • 子类所有的构造方法都会默认去访问父类的空参数构造方法

原因 : 因为子类在初始化时 , 可能会用到父类的数据 , 所以通过访问父类的构造 , 先给父类进行初始化

如果进行初始化呢 ?

每个构造方法中默认第一条语句都会有一个super()

如果父类没有空参数构造 , 那么子类如果进行给父类初始化 ?

子类可以通过super(…)访问父类的有参数构造方法

子类通过this(…)访问子类的有参构造 , 在通过有参构造区访问父类的有参构造 , 不推荐

注意事项 :

super(…) 和 this(…) 因为二者都需要放在构造方法的第一条可执行语句, 所以二者不能共存


3.8 方法重写


  • 什么是方法重写 ?
  • 子类和父类出现了一模一样的方法的声明(方法名 , 参数列表)
  • 为什么要学习方法重写 ?
  • 当子类需要使用父类的功能 , 但是父类的功能又满足不了子类 , 那么子类需要重写 , 这样既可以使用父类的功能 ,也可以增加新的功能
  • 如果进行方法重写 ?

子类和父类的方法声明一样 , 方法体中的内容重新定义

Override注解是做什么的,有什么用?

@Override是放在重写后的方法上,作为重写是否正确的校验注解,加上该注解后如果重写错误,编译阶段会出现错误提示。建议重写方法都加@Override注解,代码安全,优雅!

  • 方法重写的注意事项 ?
  • 私有的方法无法重写
  • 重写的方法与被重写的方法 , 名字 , 参数列表需要保持一致
  • 子类重写父类方法时,子类方法访问权限必须大于或者等于父类方法权限 (暂时了解 :缺省 < protected < public)
  • 一般保持一致即可


3.9 this和super关键字的区别


  • this : 代表的是本类的对象
  • super : 代表的是父类数据存储空间(可以看做成父类的对象)
  • 使用 :

调用变量 :

this.变量名 : 访问本类的成员变量

super.变量名 : 访问父类的成员变量

调用方法 :

this.方法名(…) : 访问本类的成员方法

super.方法名(…): 访问父类的成员方法

调用构造 :

this.构造方法名(…) : 访问本类的构造方法

super.构造方法名(…) : 访问父类的构造方法


4 抽象类


4.1 抽象类 :


  • 抽象类其实就是为抽象方法提供存活的空间 , 需要在类的前面加上上abstract关键字进行修饰
  • 抽象类的作用主要是规范子类必须实现某种规则


4.2 抽象方法 :


  • 一个方法要么有方法体 , 要么是一个抽象方法


4.3 抽象类的注意事项 :


  • 抽象方法和抽象类必须使用abstract关键字进行修饰
  • 抽象类中可以抽象方法 , 也可以有非抽象方法 , 抽象方法必须存在抽象类中
  • 抽象方法的作用 : 让子类必须实现此功能
  • 非抽象方法的作用 : 让子类去继承此功能
  • 抽象类不能实例化
  • 抽象类的子类
  • 要么是一个抽象类
  • 要么重写所有的抽象方法
/*
    注意事项
        1 抽象方法和抽象类必须用关键字 abstract
        2 抽象类中可以有抽象方法 , 也可由非抽象方法
          但是抽象方法必须存在抽象类中
          非抽象方法 : 让子类去继承 , 提高代码的复用性
          抽象方法 : 让子类必须完成某些功能(规范)
        3 抽象类不能进行实例化(不能创建对象)
        4 抽象的子类
            要么重写所有的抽象方法
            要么这个子类是一个抽象类

        抽象类虽然不能创建对象 , 但是存在构造方法
        构造方法存在的意义 : 让子类去通过super访问 , 从而给抽象类中的私有变量赋值
 */
public class AnimalTest {
    public static void main(String[] args) {
        // 抽象类不能进行实例化(不能创建对象)
        // Animal a = new Animal();
    }
}
// 抽象类案例
public abstract class Animal {
    private String breed;
    private String color;

    public Animal() {
    }

    public Animal(String breed, String color) {
        this.breed = breed;
        this.color = color;
    }

    public String getBreed() {
        return breed;
    }

    public void setBreed(String breed) {
        this.breed = breed;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    // 抽象方法
    public abstract void eat();

    public void drink(){
        System.out.println("喝水....");
    }
}

public class Dog extends Animal{
    public Dog(){
    }

    public Dog(String breed , String color){// breed = "边牧" ,color = "黑白"
        super(breed , color);
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头!");
    }
}
/*
    需求:
    定义猫类(Cat)和狗类(Dog)

  猫类成员方法:eat(猫吃鱼)drink(喝水…)
  狗类成员方法:eat(狗吃肉)drink(喝水…)

  向上抽取父类 :
      Animal类 : 品种 , 颜色 , eat();  , drink(){喝水…}

 */
public class AnimalTest {
    public static void main(String[] args) {
        // 空参构造 + set
//        Dog d1 = new Dog();
//        d1.setBreed("哈士奇");
//        d1.setColor("黑白相间");
//        System.out.println(d1.getBreed() + "---" + d1.getColor());
//        d1.drink();
//        d1.eat();

        // 全参构造
        Dog d2 = new Dog("边牧" , "黑白");
        System.out.println(d2.getBreed() + "---" + d2.getColor());
    }
}

相关文章
|
18小时前
|
Java 开发者
告别单线程时代!Java 多线程入门:选继承 Thread 还是 Runnable?
【6月更文挑战第19天】在Java中,面对多任务需求时,开发者可以选择继承`Thread`或实现`Runnable`接口来创建线程。`Thread`继承直接但限制了单继承,而`Runnable`接口提供多实现的灵活性和资源共享。多线程能提升CPU利用率,适用于并发处理和提高响应速度,如在网络服务器中并发处理请求,增强程序性能。不论是选择哪种方式,都是迈向高效编程的重要一步。
|
23小时前
|
安全 Java 数据安全/隐私保护
Java基础之类封装、继承、多态
Java基础的封装、继承和多态是OOP的核心。封装通过访问控制(如private)隐藏类的内部细节,提供公共接口供外部交互。例如,`Person`类封装`name`和`age`,通过`getName()`和`setAge()`方法访问。继承允许子类(如`Dog`)继承父类(如`Animal`)的属性和方法,并可扩展或覆盖。多态使得父类引用可指向子类对象,调用方法时根据实际对象类型执行,如不同动物的`makeSound()`。接口实现多态提供了一种定义行为而不必关心实现的方式。向上转型(子类→父类)安全且默认,而向下转型(父类→子类)需类型检查以避免异常。
6 1
|
1天前
|
Java 数据安全/隐私保护 开发者
Java是一种完全支持面向对象编程的语言,其面向对象特性包括封装、继承、多态和抽象等
【6月更文挑战第18天】**面向对象编程(OOP)通过对象封装状态和行为,实现问题域的抽象。Java全面支持OOP,核心特性包括**: - **封装**:保护数据安全,隐藏内部细节。 - **继承**:子类继承父类属性和行为,促进代码重用。 - **多态**:一个接口多种实现,增强灵活性和扩展性。 - **抽象**:通过接口和抽象类抽离共性,简化复杂性。 **Java的OOP便于理解和解决复杂系统问题。**
12 3
|
1天前
|
安全 Java 开发者
类与对象:Java中的封装、继承与多态
Java面向对象三大特性:封装(隐藏对象细节,增强安全与复用),继承(代码复用与扩展,如Dog继承Animal),多态(统一接口,不同实现,如Playable接口的Piano和Guitar)。通过示例展示了如何在实践中应用这些概念。【6月更文挑战第16天】
12 2
|
2天前
|
Java
Java编程不再难:一文看懂抽象类与接口的区别和联系!
【6月更文挑战第17天】在Java OOP中,抽象类与接口助你构建复杂应用。以图书管理系统为例,抽象类`Book`作为基类提供共享属性和方法,不直接实例化。接口如`HasChapters`和`HasIssues`定义特殊行为。抽象类支持部分实现,单继承,适合共享行为;接口仅含常量和抽象方法,多实现,强调行为规范。通过继承和实现,实现代码复用和系统扩展性。理解两者异同,是提升Java编程能力的关键。
|
2天前
|
Java 开发者 C++
Java面向对象的终极挑战:抽象类与接口的深度解析!
【6月更文挑战第17天】在Java OOP中,抽象类和接口助力代码复用与扩展。抽象类不可实例化,提供通用框架,适合继承;接口包含纯抽象方法,支持多态与松耦合。选择抽象类用于继承已有方法和状态,接口则适用于不相关类共享行为。Java 8后接口能含默认方法,增加设计灵活性。抽象类与接口常结合使用,以实现最佳设计,如`Shape`抽象类实现`Drawable`和`Selectable`接口,展现两者协同优势。理解和熟练运用这对概念是提升代码质量的关键。
|
2天前
|
Java
Java编程界的黑魔法:利用抽象类和接口提升你的代码质量!
【6月更文挑战第17天】在Java中,抽象类和接口是提升代码质量的关键。抽象类通过提供共享接口和部分实现减少冗余,强制子类实现标准,并作为扩展点。接口则定义行为契约,促进多态性、松耦合和易扩展性。两者结合使用,可以在保证灵活性的同时增强代码结构和可维护性,为复杂系统的构建打下坚实基础。
|
2天前
|
Java 测试技术 开发者
超越普通Java开发者:掌握抽象类与接口的高级技巧!
【6月更文挑战第17天】在Java编程中,抽象类和接口是提升代码质量和可维护性的核心要素。通过抽象类实现基类定制,如预设实现并强制子类实现特定方法;接口则提供多继承及默认、静态方法,增强复用和模块化。两者结合使用,抽象类封装状态和行为,接口专注行为契约,利于单元测试中的模拟对象创建。掌握这些技巧,能助你编写出更优雅、高效的代码。
|
2天前
|
存储 Java 开发者
Java编程新视角:抽象类和接口,你不知道的秘密!
【6月更文挑战第17天】在Java中,抽象类与接口是抽象概念的关键工具。抽象类是不可实例化的模板,包含抽象和具体方法,适合有层次结构的继承;接口仅含抽象方法,像契约般规定实现类的行为,适用于无关对象间的统一接口。Java类单继承但可多实现接口,增加设计灵活性。理解并巧妙运用二者,能提升代码质量和可维护性。
|
2天前
|
Java 开发者
别再写错代码了!Java抽象类与接口的正确使用姿势!
【6月更文挑战第17天】在Java中,抽象类与接口助力构建灵活代码结构,提升效率。抽象类用于定义公共行为和属性,适合有层次的对象集合;接口包含抽象方法,实现多态,适合不相关对象集合。通过示例展示了如何创建抽象类和实现接口,强调理解其核心价值和使用场景的重要性,以提升代码质量和设计。正确使用抽象类与接口,让代码从平凡走向专业。