面向对象的一些知识

最新推荐文章于 2024-08-01 15:05:06 发布

sHiner

最新推荐文章于 2024-08-01 15:05:06 发布

阅读量296

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_43096888/article/details/123686354

版权

初识面向对象

面向过程&面向对象

**面向过程：**步骤清晰简单，第一步要做什么，第二步要做什么

面向对象：

分类的思维模式、思考解决问题需要哪些分类，然后对这些分类进行单独的思考，最后，才对某个分类的细节进行面向过程的思索。
适合处理复杂问题、适合处理需要多人协作的问题

什么是面向对象（OOP）？

本质：以类的方式组织代码、以对象的组织封装数据

抽象

三大特性：

封装：把数据包装起来，然后对外提供接口
继承：A类继承了B类，可以继承所有B类的功能
多态：几个类收到相同的消息，会执行不同的功能

方法回顾和加深

方法的定义：

break和return的区别

break：跳出switch

return代表方法结束，return的返回值和返回类型要一致

方法名：注意驼峰命名原则，见名知意。
异常抛出

方法的调用

静态方法

两个静态方法可以互相调用的，但一个静态的不能调用非静态的，静态方法。

形参和实参

public static void main(String[] args) {
    //如果add（）不是静态方法，就用new
    //new demo().add(2,3);
    //如果add（）是静态方法
    int add = demo.add(2, 3);//先写demo.add(2,3)，再alt+enter
    System.out.println(add);
    //实际参数和形式参数的类型要一一对应，形式参数只是参数的名字，实际参数才有值。
}
public static int add(int a,int b){
    return a+b;
}

值传递和引用传递、

//值传递
public class demo04 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        demo04.change(a);
        System.out.println(a);
    }
    //返回值为空
    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);

        demo05.change(person);
        System.out.println(person.name);
    }
    public static void change(Person person){
        person.name="yyk";//person是一个对象
    }
}
//定义了一个类person,有一个属性：name
class Person{
    String name;
}

类和对象的关系

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

对象是抽象概念的具体实例

创建与初始化对象

使用关键字new类创建对象：new时，会分配内存空间,并且给创建好的对象进行默认的初始化，以及类中构造器的调用。

构造器

main类

public static void main(String[] args) {
    //类是抽象得到，需要实例化,实例化后会返回一个自己的对象
    //student对象就是一个Student类的具体实例
    Student student = new Student();

    Person person = new Person();//实例化了一个对象
    System.out.println(person.name);
}
/*
构造器：
1.和类名相同
2.没有返回值
作用：
1.new本质是调用构造方法
2.初始化对象的值
注意点：
定义有参构造之后，如果想使用无参构造，显示定义一个无参的构造
 */

person类

public class Person {
    //一个类即使什么都不写，也有一个构造器
    //显示定义构造器

    String name;

//    //实例化初始值
//    public Person(){
//        this.name="yyk";
//    }//无参构造
//
//    //构造器的作用：
//    //1.使用new关键字必须要有构造器，本质就是调用构造器
//    //2.构造器一般用来初始化值
//
//    //有参构造:一旦构造了有参构造，无参构造必须显示定义
//    public Person(String name){
//        this.name=name;
//    }


    //生成构造器的方法：alt+shift+insert(小键盘的0）
    public Person() {
    }

    public Person(String name) {
        this.name = name;
    }
}

小结：

类是一个模板，对象是一个具体的实例
方法

定义：调用

对应的引用

引用类型：基本类型（8）

对象是通过引用来操作的：栈——>堆

属性：字段field成员变量

默认初始化：数值：0/0.0

char:u000

boolean:false

引用：null

修饰符属性类型属性名=属性值

对象的创建和使用

必须使用new关键字创造对象，构造器 new Person();

对象的属性 person.name

对象的方法 person.sleep();

类：

静态的属性

动态的方法

面向对象三大特性

封装

程序设计要求：高内聚，低耦合。

get/set 属性私有

优势：

提高了程序的安全性、保护数据
隐藏代码的实现细节
统一接口
系统可维护能力增强

 private String name;
    private int ID;
    private char sex;
    private int age;


    //提供一些public的get、set的方法
    public String getName(){
        return this.name;
    }
    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<=120&&age>=0){
        this.age = age;
        }
        else {
            System.out.println("年龄不合法！");
//          this.age=3;
        }
    }

public static void main(String[] args) {
    Student s1 = new Student();
    s1.getName();
    s1.setName("yyk");
    s1.getName();
    System.out.println(s1.getName());
    s1.setAge(999);
    System.out.println(s1.getAge());
}

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是扩展，子类是父类的扩展
继承是类与类之间的关系，此外类与类的关系还有依赖、组合、聚合
子类继承了父类，就会继承父类的全部方法
在Java中，所有的类都默认继承object类
Java中，只能单继承，一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

super

private int money=100000;
protected String name="yyk";


public void say(){
    System.out.println("说了一句话");
}

public int getMoney() {
    return money;
}

public void setMoney(int money) {
    this.money = money;
}

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

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

public Person(String name) {
    this.name = name;
}
//修饰符：
    //public
    //protected
    //default
    //private

public class Student extends Person{
    private String name="yyk1";
    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);//本类的name
        System.out.println(super.name);//父类的name
    }

    public void print(){
        System.out.println("本类print");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
    public Student(){
        super();//隐藏代码，不写也在，调用了父类的无参构造，而且super（）必须在子类构造器的第一行
        System.out.println("Student无参构造执行");
    }
    /*
    super的注意点：
    1.super调用父类的构造方法，必须在构造方法的第一行
    2.super必须只能出现在子类的方法或者构造方法中
    3.super和this不能同时调用构造函数

    this VS super:
    代表的对象不同：
    this:本身调用这个对象
    super:代表父类对象的应用
    前提：
    this:没有继承也可以使用
    super:只能在继承条件下才可以使用
    构造方法：
    this();本类的构造
    super();父类的构造
     */
}

重写

	//静态方法和非静态方法重写完全不同
    //如果是静态方法，方法的调用只和左边定义的数据类型有关
    //非静态的方法：可以重写，
    //即b是A new出来的对象，因此调用了A的方法，
    // 因为静态方法是类的方法，而非静态是对象的方法，
    // 有static时，b调用了B类的方法，
    // 因为b是用b类定义的没有static时，b调用的是对象的方法，而b是用A类new的

/*重写：需要继承关系，只有子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符的范围可以扩大，public>protected>Default>private
4.抛出的异常的范围可以被所有，但不能扩大
重写子类和父类必须要一致，方法体不同
Q:那么为什么需要重写呢？
A:父类的功能子类不一定需要，或者不一定满足
 */

public class B {
    //重写都是方法的重写，和属性无关
    public static void test(){
        System.out.println("Btest");
    }
}

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

多态

public class Application {
    public static void main(String[] args) {
    //类型转换：基本类型，高转低
        //高                   低
        Person student = new Student();

        //student.go();//报错：原因是这是高类型，不能自己转换为低类型
        //需要进行强制转换
        Student student1 = (Student) student;
        student1.go();
        //((Student)student).go();//第二种写法
        //子类转化为父类，可能会失去一些方法
        //父类引用指向子类的对象
        //把子类转换为父类，向上转换
        //父类转换为子类，向下转型，强制转换
        //为什么会需要强制转换，减少重复的代码，为了利用不同类内的方法
    }
}
/*
多态：
多态是方法的多态，属性没有多态
2.父类和子类，有联系   类型转换异常：ClassCastExption
3.存在条件：继承关系，方法需要重写，父类的引用指向的是子类对象

注意事项
1.static类不能重写，不属于实例
2.final修饰的是常量，也不能重写
3.private 修饰的，也不能重写
不能重写肯定没有多态

类型转换
        //Person person = new Person();
        //一个对象的实际类型是确定的，可以指向的引用类型就不确定了
        //子类能调用的方法 只能是自己的或者父类继承的
        //父类虽然能指向子类，但是不能调用子类的方法
        Student s1 = new Student();
        Person s2 = new Student();//用父类来new子类
        Object s3 = new Student();
        Person s4 = new Person();
        s4.run();
        s1.eat();
        s2.run();
        //s2.eat();
        //一旦子类执行了父类的方法，执行了子类的方法

        //object>person>student
        System.out.println("===========");
        Object object = new Student();
        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

        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);//编译error

        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);//编译error
        //System.out.println(student instanceof String);//编译error

        //System.out.println(x instanceof y);
        //能不能编译通过，取决于x和y之间是不是存在父子关系
        //这个结果是T还是F，取决于x指向的实际类型是不是Y的子类型
 */

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("Son eat");
    }
    public void go(){

    }
}

public class Teacher extends Person{
}

static

private static int age;
private double score;

public void run(){
    //非静态方法
    //可以调用静态方法
}

public static void go(){
    //静态方法
    //不可以调用静态方法
}
public static void main(String[] args) {



    //静态变量可以直接调用，非静态还需要new
    Student student = new Student();

    System.out.println(Student.age);
    //System.out.println(Student.score);
    System.out.println(student.age);
    System.out.println(student.score);
}

静态代码块

{
    //匿名代码块，程序执行的时候不能去调用
    //一般用来赋予初始值
    System.out.println("匿名代码块");
}
static{
    //静态代码块，类加载的时候就已经执行，且只执行一次
    System.out.println("静态代码块");
}
public Person(){
    System.out.println("构造方法");
}

public static void main(String[] args) {
    Person person = new Person();
    //结果：
    // 静态代码块
    //匿名代码块
    //构造方法
}

抽象类

abstract修饰符

抽象类的所有方法，继承了它的子类，都必须要实现它的方法，

特点：不能new抽象类，只能考子类去实现它：起一个约束的作用

抽象类里面可以写普通的方法

抽象方法必须写在抽象类里面

抽象类存在的意义是什么？

接口

普通类：只有具体实现

抽象类：具体实现和规范都有

接口：只有规范，自己无法写方法，专业的约束，可以实现约束和实现分离

接口关键词：implement

接口的作用：

约束
定义一些方法，让不同的人实现
方法都是public abstract，常量都是 public static final
接口不能被实例化，接口没有构造方法
实现了接口的类，就需要就要重写接口中的方法
虽然 java 单继承，但是接口可以实现多继承

内部类

内部类就是在一个类内部定义一个类，比如在A类中定义一个B类，那么B类就是内部类

成员内部类
静态内部类：一个static内部类不可以调用一个非静态外部类
局部内部类：在方法里面也可以声明一个类
匿名内部类：没有名字初始化类，不能讲实例保存在变量中

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

sHiner

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象的一些知识

初识面向对象面向过程&面向对象**面向过程：**步骤清晰简单，第一步要做什么，第二步要做什么面向对象：分类的思维模式、思考解决问题需要哪些分类，然后对这些分类进行单独的思考，最后，才对某个分类的细节进行面向过程的思索。适合处理复杂问题、适合处理需要多人协作的问题什么是面向对象（OOP）？本质：以类的方式组织代码、以对象的组织封装数据抽象三大特性：封装：把数据包装起来，然后对外提供接口继承：A类继承了B类，可以继承所有B类的功能多态：几个类收到相同的消息
复制链接

扫一扫