JAVA基础学习（六）------面向对象编程

最新推荐文章于 2024-07-26 12:28:02 发布

钟情_

最新推荐文章于 2024-07-26 12:28:02 发布

阅读量171

点赞数

分类专栏： Java学习笔记文章标签： java 多态抽象类封装

本文链接：https://blog.csdn.net/weixin_44176393/article/details/108983038

版权

Java学习笔记专栏收录该内容

15 篇文章 1 订阅

订阅专栏

Java的核心思想就是OOP

初识面向对象（面向过程&面向对象）

类 = 属性 + 方法

面向过程思想

1、步骤清晰简单，第一步做什么，第二步做什么

2、面向过程适合处理一些较为简单的问题
面向对象思想：

1、物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类下的细节进行面向过程的思索

2、面向对象适合处理复杂的问题，适合处理需要多人协作的问题
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统，但是，具体到微观操作，仍然需要面向过程的思路去处理

什么是面向对象

面向对象编程（Object-Oriented Programming，OOP）
面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织（封装）数据
抽象
三大特性：封装、继承、多态
从认识论角度考虑是先有对象后有类，对象，是具体的事物；类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象，类是对象的模板

回顾方法及加深

方法的定义

修饰符
返回类型
break：跳出switch，结束循环

注：注意return和break的区别

return：结束方法，返回值

public static void main(String[] args) {

    }
    /*
        修饰符 返回值类型 方法名（...）{
            //方法体
            return 返回值;
        }
     */
    public String sayHello(){
        return "hello,world";
    }
    public int max(int a,int b){
        return a>b ? a : b;  //三元运算符
    }

方法名：见名知意
参数列表：（参数类型，参数名）

异常调出

public void readFile(String file)throws IOException{ }

方法的调用

静态方法

非静态方法

  public static void main(String[] args) {
        //实例化这个类
        //对象类型 对象名 = 对象值；
        Student student = new Student();
        student.say();
    }

    public void a(){
        b();
    }
    //类实例化之后才存在
    public void b(){}
    //和类一起加载的
	//静态方法没办法调用非静态 下面这种方式是错的
    public static void c(){
        b();
    }

形参和实参

public static void main(String[] args) {
        //实际参数和形式参数的形式要对应
        int add = Demo03.add(1,2);
        System.out.println(add);
    }

    public static int add(int a,int b){
        return a+b;
    }

值传递和引用传递

值传递：

public static void main(String[] args) {
        int a = 1;
        System.out.println(a);    //1
        Demo04.change(a);
        System.out.println(a);    //1
    }
    //返回值为空
    public static void change(int a){
        a = 10;
    }

引用传递：

public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);  //null
        Demo05.change(person);
        System.out.println(person.name);  //zzz
    }
    public static void change(Person person){
        //新建的person是一个对象，指向的是具体对象person 可以改变属性
        person.name = "zzz";
    }
}
//定义一个preson类  有一个属性：name
class Person{
    String name;
}

this关键字

类和对象的关系

类是一种抽象的数据类型，它是对某一事物整体描述或定义，但是并不能代表某一个具体的事物

1、动物、植物、手机、电脑…

2、Person类、Pet类、Car类等，这些类都是用来描述或定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例

1、张三就是人的具体实例，张三家里的旺财就是狗的具体实例

2、能够体现出特点，展现出功能的是具体实例，而不是一个抽象概念

创建与初始化对象

new关键字用于创建对象，使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：

1、必须和类名相同

2、必须没有返回类型，也不能写void
构造器必须要掌握！

//学生类
public class Student {
    //属性：字段
    String name;
    int age;

    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

public class Application {
    public static void main(String[] args) {
        //类：抽象的 需要实例化
        //类实例化后会返回一个自己的对象
        //xiaoming对象就是一个Student类的具体实例
        Student xm = new Student();
        Student hhh = new Student();

        xm.name = "小明";
        xm.age = 20;
        System.out.println(xm.name);  //小明
        System.out.println(xm.age);   //20

        System.out.println(hhh.name); //null
        System.out.println(hhh.age);  //0

    }
}

构造器详解

快捷键（生成getset）： Alt + Insert 或右键 ------ Generate…

构造器特点：和类名相同，没有返回值
作用：

1、new本质在调用构造方法

2、初始化对象的值
注意点：定义了有参构造之后，如果想使用无参构造，显式的定义一个无参的构造

public class Person {
    //一个类即使什么都不写，也会存在一个方法
    //显示的定义构造器
    String name;
    int age;
    //实例初始化 无参构造
    public Person(){}
    //有参构造：一旦定义了有参构造，无参构造必须显式定义
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public static void main(String[] args) {
        //实例化了一个对象
        Person person = new Person();
        System.out.println(person.name);  //null
    }

创建对象内存分析

栈中是引用变量名或方法，指向的是堆中的对象

静态方法区：static 和类一起加载所有人都可以调用

public class Pet {
    public String name;
    public int age;

    public void shout(){
        System.out.println("汪！");
    }
}
//加载Application 方法 常量池：可乐
public class Application {
    public static void main(String[] args) {
        //方法区中 加载Pet类 方法
        //在栈中生成引用变量名dog
        //在堆中new Pet() 有对应地址
        Pet dog = new Pet();
        //给堆中对象赋值
        dog.name = "可乐";
        dog.age = 2;
        //堆中的对象调用方法区中的shout()方法
        dog.shout();

        System.out.println(dog.age);
        System.out.println(dog.name);

    }
}

封装

封装：属性私有：get/set
该露的露，该藏的藏

程序设计追求**“高内聚，低耦合”**

高内聚：类的内部数据操作细节自己完成，不允许外部干涉

低耦合：仅暴露少量的方法给外部使用
封装（数据的隐藏）

通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口访问，这称为信息隐藏
封装的作用：
1. 提高程序安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护性增加

public class Student {
    //属性私有 无法直接调用
    private String name;
    private int id;
    private char sex;
    private int age;
    //提供一些可以操作这个属性的方法
    //提供一些public的get/set方法

    //get：获得这个数据
    public String getName(){
        return this.name;
    }
    //set：给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>130 || age<0){
            this.age = 3;
        }
       else{
           this.age = age;
        }
    }
}

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("zzz");
        System.out.println(s1.getName());

        s1.setAge(-1);//不合法的
        System.out.println(s1.getAge());
    }
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是“扩展”，子类是父类的扩展
Java中类只有单继承，没有多继承
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等
继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该具有“is a”的关系

//Person 人：父类
//public protected default private
//一般属性私有 方法公有
//在Java中 所有类 都直接或间接继承Object类
public class Person {
    public void say(){
        System.out.println("说了一句话");
    }
    public int money = 100;
}

//学生 is 人 ： 派生类 子类
//子类继承了父类 就会拥有父类的全部(公有)方法
public class Student extends Person{

}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        System.out.println(student.money);
    }
}

快捷键：ctrl+H 调出继承树
在Java中所有类都直接或间接继承Object类

super类

1、super调用父类的构造方法，必须在构造方法的第一行

2、super必须只能出现在子类的方法或者构造方法中

3、super和this不能同时调用构造方法

super与this比较

代表对象不同：

this：本身调用者这个对象

super：代表父类对象的引用

前提：

this：没有继承也可以使用

super：只能在继承条件下才能使用

构造方法：

this：本类的构造

super：父类的构造

public class Person {
    protected String name = "zzz";

    public void print(){
        System.out.println("Person");
    }

    public Person() {
        System.out.println("Person无参执行了");
    }
}

public class Student extends Person{
    private String name = "ttt";

    public Student() {
        //隐藏代码：调用了父类的无参构造

        super();//调用父类构造器必须在子类第一行
        System.out.println("Student无参构造执行了");
    }

    public void test(String name){
        System.out.println(name);         //参数
        System.out.println(this.name);    //ttt 子类
        System.out.println(super.name);   //zzz 父类
    }

    public void print(){
        System.out.println("Student");
    }

    public void test1(){
        print();         //子类方法
        this.print();    //子类方法
        super.print();   //父类方法
    }
}

public static void main(String[] args) {
        Student student = new Student();
        student.test("mmm");
        student.test1();

    }

方法重写

重写都是方法的重写与属性无关

静态方法：方法的调用只和定义的数据类型有关

public class B {
    public static void test(){
        System.out.println("B=>test()");
    }
}
public class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的调用只和定义的数据类型有关
        A a = new A();
        a.test();     //A

        //父类的引用指向了子类
        B b = new A();
        b.test();     //B

    }
}

非静态：重写方法

public class B {
    public void test(){
        System.out.println("B=>test()");
    }
}
public class A extends B{
    //Override 重写
    @Override
    public void test(){
        System.out.println("A=>test()");
    }
}

public static void main(String[] args) {
        //方法的调用只和定义的数据类型有关
        A a = new A();
        a.test();       //A

        //父类的引用指向了子类
        B b = new A();  //子类重写了父类的方法
        b.test();       //A

    }

重写特点：

需要有继承关系，子类重写父类的方法

1、方法名必须相同

2、参数列表必须相同

3、修饰符：范围可以扩大不能缩小：
public > protected > default > private

4、抛出的异常：范围可以被缩小，但是不能扩大：ClassNotFoundException（某个异常） ------- Expection（大）

重写子类的方法和父类必须要一致，方法体不同

为什么需要重写？

父类的功能子类不一定需要，或不一定满足

多态

动态编译：类型—可扩展性

即同一个方法可以根据发送对象的不同而采取多种不同的行为方式
可以用父类new子类，这就是多态
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

多态存在的条件：

1、有继承关系

2、子类重写父类方法

3、父类引用指向子类对象

注：多态是方法的多态，属性没有多态

public class Person {
    public void run(){
        System.out.println("person run");
    }
}

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("student run");
    }

    public void eat(){
        System.out.println("eat");
    }
}

public class Application {
    public static void main(String[] args) {

        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run();  //子类重写了父类的方法 执行子类的方法

        s1.eat();
        //s2.eat(); 父类不能调用子类的方法
    }

}

对象能执行哪些方法，主要看对象左边的类型和右边关系不大

子类型能调用的方法都是自己的或者继承父类的

父类型可以指向子类，但是不能调用子类独有的方法
Person（引用类型） s2 = new Student()（实际类型）;

多态注意事项：

1、多态是方法的多态，属性没有多态

2、父类和子类必须有联系（类型转换异常）ClassCastException

3、拥有这些关键词无法重写，也就没办法拥有多态：static（属于类不属于实例），final（常量），private

instanceof

引用类型，判断一个对象是什么类型，不能没有父子关系

判断 A instanceof B ，是看 A 与 B 是否有关系，有输出 true 没有输出 false

public class Teacher extends Person{}

public class Student extends Person{}

public class Person {}

public class Application {
    public static void main(String[] args) {
        //Object>Person>Student
        //Object>Person>Teacher
        Object object = new Student();
        //判断A instanceof B ，是看 A 与 B 是否有关系，有输出true 没有输出false
        System.out.println(object instanceof Student);    //true
        System.out.println(object instanceof Person);     //true
        System.out.println(object instanceof Object);     //true
        System.out.println(object instanceof Teacher);    //false
        System.out.println(object instanceof String);     //false

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

        Person person = new Student();
        System.out.println(person instanceof Student);    //true
        System.out.println(person instanceof Person);     //true
        System.out.println(person instanceof Object);     //true
        System.out.println(person instanceof Teacher);    //false
       // System.out.println(person instanceof String);    编译报错 person和string无关

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

        Student student = new Student();
        System.out.println(student instanceof Student);    //true
        System.out.println(student instanceof Person);     //true
        System.out.println(student instanceof Object);     //true
        // System.out.println(student instanceof Teacher);    编译报错 student和teacher无关
        // System.out.println(student instanceof String);     编译报错 student和string无关
    }

}

System.out.println(A instanceof B);是否可以编译通过

类型转换

由父类转换为子类，向下转型，需要强制转换

public class Application {
    public static void main(String[] args) {
        //类型之间的转换：父---子
        //高----低
        Person obj = new Student();
        //student将这个对象转换成Student类型，就可以用Student的方法了
        Student student = (Student)obj;
        student.go();
        //合并成一句话((Student)obj).go;
    }
}

由子类转换为父类，向上转型，自动转换

public class Application {
    public static void main(String[] args) {
        //类型之间的转换：子---父
        //低----高
        //子类转换为父类，可能会丢失自己本来的一些方法
        Person person = student;
        //person.go(); 无法调用
    }
}

子类转换为父类，可能会丢失自己本来的一些方法

static关键字详解

通过final修饰的类不能被继承，没有子类

静态属性

静态变量可以用类名直接调用，非静态变量不可以

public class Student {
    private static int age;//静态变量
    private double score;//非静态变量

    public static void main(String[] args) {
        Student s1 = new Student();

        System.out.println(Student.age);
        System.out.println(s1.age);
        System.out.println(s1.score);
    }
}

静态方法

非静态方法可以直接访问类中的静态方法

静态方法之间可以互相调用

非静态方法：对象名.方法名

静态方法：类名.方法名或直接写方法名

public class Student {
  private static int age;//静态变量
  private double score;//非静态变量

  public void run(){
      go();
  }

  public static void go(){ }

  public static void main(String[] args) {
      Student.go();
      go();
  }
}

静态代码块

匿名代码块，程序在执行的时候并不能主动调用其中的内容

静态代码块，从程序开始就执行且只执行一次

public class Person {
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    static{
        //静态代码块
        System.out.println("静态代码块");
    }
    public Person(){
        System.out.println("构造方法");
    }

     public static void main(String[] args) {
        Person person1 = new Person();
         //静态代码块 匿名代码块 构造方法
        System.out.println("-------------------------------");
        Person person2 = new Person();
         //匿名代码块 构造方法
    }
}

静态导入包

静态导入包后可直接写方法（不常用）

import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Test {
    public static void main(String[] args) {
        //返回随机数
        System.out.println(Math.random());
        //静态导入包后可直接写方法
        System.out.println(random());
        System.out.println(PI);
    }
}

抽象类

abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，该方法是抽象方法；如果修饰类，该类是抽象类

//抽象类 类 extends 单继承；接口可以多继承
public abstract class Action {
    //约束 有人帮我们实现
    //抽象方法，只有方法名，没有方法实现
    public abstract void doSomething();
}

//抽象类的所有方法，继承他的子类都必须要实现，除非子类也是抽象
public class A extends Action {
    @Override
    public void doSomething() {
    }
}

抽象方法：只有方法的声明，没有方法的实现，他是用来让子类实现的
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

抽象类的特点：

1、抽象类不能用new关键字来创建对象，他是用来让子类继承的，是一种约束

2、抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类

3、抽象方法必须在抽象类中

抽象类存在构造器吗？

抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。

在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。

抽象类存在的意义

1、更利于代码的维护和重用

2、因为抽象类不能实例化对象，所以必须要有子类来实现它之后才能使用。这样就可以把一些具有相同属性和方法的组件进行抽象，这样更有利于代码和程序的维护

3、当又有一个具有相似的组件产生时，只需要实现该抽象类就可以获得该抽象类的那些属性和方法

接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有
接口：只有规范，自己无法写方法，专业的约束（约束和实现分离）面向接口编程
接口就是规范，定义一组规则，体现了现实世界中”如果你是…则必须能…“的思想。
接口的本质是契约，就像我们人间的法律一样，制定好后大家遵守
OO的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备抽象能力的语言（比如c++、java、c#等），因为设计模式所研究的，实际上就是如何合理的去抽象
声明类的关键字是class，声明接口的关键字是interface

//interface 定义的关键字 ，接口都需要有实现类
public interface UserService {
    //定义的是常量 默认 public static final（不常用）
    int age = 99;
    
    //接口中的所有定义的方法都是抽象的  默认public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void timer();
}

//实现类一般用Impl结尾
//类 可以实现接口 implements接口
//实现了接口的类 必须重写里面的所有方法

//利用接口侧面实现多继承
public class UserSreviceImpl implements UserService,TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口的作用：

1、约束

2、定义一些方法，让不同的人实现

3、接口中的所有定义的方法都是抽象的默认public abstract

4、定义的是常量（不常用）默认 public static final

5、接口不能直接被实例化，因为接口中没有构造方法

6、接口可以实现多个（例：public class UserSreviceImpl implements UserService,TimeService），但必须重写接口中所有方法
7、接口也可以用来声明一个变量

内部类

内部类就是在一个类的内部定义一个类

例：A类中定义一个B类，那么B类相对与A类来说就称为内部类，A类相对B类来说就是外部类

一个java类中可以有多个class类，但是只能有一个public class

成员内部类

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

public class Application {
    public static void main(String[] args) {

        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
    }

}

调用内部类：（分为两步）

1、外部类名外部类对象名 = new 外部类名();

2、外部类名.内部类名内部类对象名 = 外部类对象名.new 内部类名();

成员内部类可以拿到外部类的私有属性

静态内部类

静态内部类无法调用外部类的私有属性

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public static class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        //获得外部类的私有属性
        public void getID(){
            //System.out.println(id);
        }
    }
}

局部内部类

public class Outer {
    public void method(){
        //局部内部类
        class Inner{
        }
    }
}

匿名内部类

没有名字初始化类，不用将实例保存到变量中

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类 不用将实例保存到变量中
        new Apple().eat();
        //可以new接口了 重写其中方法
        new UserService(){
            @Override
            public void Hello() {
                
            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("吃");
    }
}

interface UserService{
    void Hello();
}

钟情_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础学习（六）------面向对象编程

面向对象编程Java的核心思想就是OOP初识面向对象（面向过程&面向对象）类 = 属性 + 方法面向过程思想1、步骤清晰简单，第一步做什么，第二步做什么2、面向过程适合处理一些较为简单的问题面向对象思想：1、物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类下的细节进行面向过程的思索2、面向对象适合处理复杂的问题，适合处理需要多人协作的问题对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向
复制链接

扫一扫

专栏目录