Java面向对象基础

最新推荐文章于 2023-05-05 15:56:18 发布

学不会就继续学

最新推荐文章于 2023-05-05 15:56:18 发布

阅读量50

点赞数

分类专栏： JavaSE 文章标签： java

本文链接：https://blog.csdn.net/timoraty/article/details/112255144

版权

JavaSE 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

Java面向对象基础

一、面向对象与面向过程

面向过程：步骤清晰简单，一步步实现
面向对象：
- 分类的思维模式，对每一个类进行独立思考，从整体上分析
- 以类的方式组织代码，以对象的组织（封装）数据
- 三大特性：封装继承多态
- 类：类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
- 对象是抽象概念的具体实例

二、方法

静态方法有static，属于类（类加载时就加载），可以通过类名.方法直接调用
非静态方法无static 属于对象（类实例化之后才存在），先把对象new出来再通过对象名.方法调用
值传递和引用传递

基本类型是值传递，引用类型是引用传递（栈–>堆）

三、类和对象的创建

类的属性默认初始化
- 数字 0 0.0
- char u0000
- boolean：false
- 引用：null
使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用
类构造器的特点
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
构造器的作用：
- 一个类即使什么都不写也会存在一个构造方法，使用new关键字本质是在调用构造器
- 构造器可以赋初始值
构造器注意事项
- 一旦定义了有参构造，构造器就必须显式定义，否则就无效
- idea一键生成构造器 alt+insert
```
```java
```

public class Person {
//属性默认初始化
String name;
//无参构造器
Person(){
this.name=“please enter name”;
}
//有参构造器
Person(String name){
this.name=name;
}

}
```

四、面向对象三大特性

1.封装

”高内聚，低耦合“：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉，低耦合是仅暴露少量的方法给外部使用

封装-属性私有(get/set) ：通常应当进制直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

public class Person {
    //使用private属性后，属于私有变量，不能再直接改变这些变量的值
    private String name;
    //get函数，可以获得name
    public String getName() {
        return name;
    }
    //set函数，可以给name赋值
    public void setName(String name) {
        this.name = name;
    }

}

main函数调用

public class Demo01 {
    static public void main(String[] args)
    {
        Person Mary=new Person();
        Mary.setName("Mary");
        System.out.println(Mary.getName());
    }
}

2.继承

idea快捷键 ctrl+h 出现继承关系
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
继承是类和类之间的关系，除此之外，类和类之间的关系还有依赖、组合、聚合等
字类可以继承父类的所有方法和属性(public)

使用extends关键字用以继承父类

Teacher.java

//extends Person表示继承自Person
public class Teacher extends Person{
    private int salary;
    public void Teaching()
    {
        System.out.println("Teaching something");
    }
}

Person.java

public class Person {
    //使用private属性后，属于私有变量，不能再直接改变这些变量的值
    private String name;
    //get函数，可以获得name
    public String getName() {
        return name;
    }
    //set函数，可以给name赋值
    public void setName(String name) {
        this.name = name;
    }
}

Demo.java


public class Demo01 {
    static public void main(String[] args)
    {
        //new一个teacher对象，这个对象继承自person，可以用person的方法
        Teacher Mary=new Teacher();
        Mary.setName("Mary");
        System.out.println(Mary.getName());
    }
}

在Java中，所有的类都默认直接或间接继承Object

super

注意点

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

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

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

4.super主要是给子类调用和父类同名的函数用的（吧…一直没弄懂这里，学会了回来补）

与this的区别

代表的对象不同：

this：本身调用者这个对象

super：代表父类对象

前提

this：没有继承也可以调用

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

构造方法

this():本类的构造

super():父类的构造

父类

public class Person {
    protected String name="person's name";
    public Person()
    {
        System.out.println("Person无参构造执行了");
    }


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

子类

public class Student extends Person{
    private String name="student's name";
    public Student(){
        //隐藏代码 调用父类构造器
        System.out.println("Student无参构造执行了");
    }
    public void print()
    {
        System.out.println("student");
    }
    public void test1(){
        print();//student
        this.print();//student
        super.print();//person
    }
    public  void test()
    {
        System.out.println(this.name);
        System.out.println(super.name);
    }

}

main函数

public class Demo {
    public static void main(String[] args)
    {
        Student s1=new Student();
        s1.test();
    }
}

方法重写

条件：有继承关系，子类重写父类的方法
规则：1.方法名必须相同

2.参数列表必须相同

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

4.抛出的异常范围可以缩小但不能扩大：ClassNotFoundException–>Exception(大)
作用:让子类实现父类没有实现的功能，或者子类去掉父类多余的功能

快捷键 atl+insert

父类

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

子类

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

main

public class Demo {
    public static void main(String[] args)
    {
        A a = new A();
        a.test();
        //父类的引用指向子类,父类子类的函数都是非静态才能实现重写,即都用A（子类）的函数
        //如果是静态方法，方法调用只和new左边的类有关，即输出A=>test B=>test
        B b=new A();
        b.test();
    }
}

3.多态

定义：同一方法可以可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）
多态是方法的多态，属性没有多态性

多态存在的条件

有继承关系
子类重写父类的方法
父类指向子类的对象 Father f1=new son();

不能重写：1.static方法（属于类，不属于实例） 2.final常量 3.private方法

父类

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

子类

public class Student extends Person{
    //重写了父类的run
    public void run()
    {
        System.out.println("student run");
    }
    public void eat()
    {
        System.out.println("eat");
    }
}

main

public class Demo {
    static public void main(String[] args)
    {
        //Student能调用的方法都是自己或者继承父类的
        Student s1=new Student();
        //Person 可以指向子类，但是不能调用子类的方法
        Person s2=new Student();

        //对象能执行的方法看的是左边的类型
        s1.eat();
        s1.run();
        s2.run();
    }
}

学不会就继续学

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java面向对象基础

Java面向对象基础一、面向对象与面向过程面向过程：步骤清晰简单，一步步实现面向对象：分类的思维模式，对每一个类进行独立思考，从整体上分析以类的方式组织代码，以对象的组织（封装）数据三大特性：封装继承多态类：类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物对象是抽象概念的具体实例二、方法静态方法有static，属于类（类加载时就加载），可以通过类名.方法直接调用非静态方法无static 属于对象（类实例化之后才存在），先把对象
复制链接

扫一扫

专栏目录