面向对象三大特性-CSDN博客

本文链接：https://blog.csdn.net/m0_64208396/article/details/129992062

面向对象

属性+方法=类

面向过程&面向对象

1.面向过程思想

步骤清晰简单，第一步做什么，第二步做什么…
面对过程适合处理一些较为简单的问题

2.面向对象思想

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

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

什么是面向对象
面向对象编程(Object-Oriented Programming, OOP)
面向对象编程的本质就是:以类的方式组织代码，以对象的组织(封装)数据。

抽象编程思想!持续的学习，茅塞顿开!多实践，多测试大脑中的想法!实践出真知~

三大特性:

封装
继承
多态

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板。

封装

该露的露，该藏的藏
我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉;低耦合:仅暴露少量的方法给外部使用。

封装(数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

记住这句话就够了:属性私有，get/set

构造器:

1．和类名相同
2．没有返回值
作用:

new本质在调用构造方法
初始化对象的值
注意点:
定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造
ALt + Insert

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBirKb97-1680768456817)(C:\Users\baijiabin\AppData\Roaming\Typora\typora-user-images\image-20230403222019407.png)]$

package aaa;

public class Pet {
    public String name;
    public int age;
    //无参构选
    public void shout(){
        System.out.println("叫了一声");
    }
}

package aaa;

public class Demo1 {
    public static void main( String[] args){
    Pet dog = new Pet();
    dog.name ="旺财";
    dog.age = 3;
    dog.shout( );   //叫了一声

    System.out.println(dog.name) ;  //旺财
    System.out.println(dog.age);    //3
    }
}

private

package aaa;
//类private:私有
public class People {
    //属性私有
    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 getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) { //不合法
            this.age = 3;
        }else {
            this.age = age;
            }
    }

}

package aaa;
/*
1。提高程序的安全性，保护数据
2。隐藏代码的实现细节
3。统一接口
4。系统可维护增加了

*/
public class Demo {
    public static void main(String[] args) {
        People p1 = new People();
        p1.setName("秦疆");
        System.out.println(p1.getName());   //秦疆
        
        p1.setAge(-1);  //不合法的
        System.out.println(p1.getAge());
    }
}

类:
静态的属性属性
动态的行为方法

继承

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

package aaa;

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

        super();//调用父类的构造器,必须要在子类的第一行,不能和下一个换行，|这行代码不写也行，它默认调用父类的无参
        //this("hello");
        System.out.println("Student无参执行了");
    }

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

    String name="qinjiang";

    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();  //Student
        this.print();   //Student
        super.print();  //Person
    }


    public void test(String name){
        System.out.println(name);   //秦疆
        System.out.println(this.name);  //qinjiang
        System.out.println(super.name);//kuangshen
    }
}

package aaa;


public class Person {
    public Person() {
        System.out.println("Person的无参执行了");    //这是构造器的无参
    }

    protected String name="kuangshen";

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

}

package aaa;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        //student.test("秦疆");
       // student.test1();
    }
}

在一个类中，如果写了一个有参构造，那么无参构造就没了，它的子类也不能继承它的无参构造，

super注意点:

  1. super调用父类的构造方法，必须在构造方法的第一个
  2. super 必须只能出现在子类的方法 或者构造方法中!
  3. super和 this 不能同时调用构造方法!
     Vs this:
     代表的对象不同:

this:本身调用者这个对象super:代表父类对象的应用

前提 this:没有继承也可以使用
super:只能在继承条件才可以使用
构造方法
this() ;本类的构造
super():父类的构造!

方法重写

重写:需要有继承关系，子类重写父类的方法!
1．方法名必须相同
2．参数列表列表必须相同
3．修饰符:范围可以扩大但不能缩小:public>protected>Default>private
4．抛出的异常:范围，可以被缩小，但不能扩大; classNotFoundException -->Exception(大)

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

为什么需要重写:
1．父类的功能，子类不一定需要，或者不一定满足!
Alt +Insert ; override;

package aaa.demo;

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

}

package aaa.demo;

public class A extends B{
   //override 重写

    @Override//注解:有功能的注释!
    //旁边的箭头代表重写了方法
    //重写的关键词只能是共有的，不能是private
    public void test() {
        System.out.println("A=>test");
    }
    /*重载和重写的不同，重载是参数名，它是相当于本类的，
    参数列表不同，重写是子父类才有的，子类继承了父类，才能
    重写，而且是子类重写了父类的方法
    */

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

package aaa.demo;

public class Application {
    public static void main(String[] args) {
        //静态的方法和非静态的方法区别很大!
        //方法的调用只和左边，定义的数据类型有关
        //重写只和非静态方法有关，和非静态方法无关
        A a = new A();
        a.test();   //A
        //父类的引用指向了子类

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

多态

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

多态存在的条件
有继承关系
子类重写父类方法
父类引用指向子类对象

注意: 多态是方法的多态，属性没有多态性。

package aaa.demo01;

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

}
/*
多态注意事项:
        1.多态是方法的多态,属性没有多态
        2.父类和子类,有联系,类型转换异常! cLasscastException !
        3.存在条件:继承关系,方法需要重写,父类引用指向子类对象!Father f1 = new Son( );
            1. static方法,属于类,它不属于实例
            2. final常量;
            3. private方法;
*/

package aaa.demo01;

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

package aaa.demo01;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了:父类的引用指向子类

        // Student能调用的方法都是自己的或者继承父类的!

        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，利右边关系不大!
        //s2.eat(); //子类重写了父类的方法，执行子类的方法
        ((Student)s2).eat();    //高转低，强制转换
        //s1.eat();
        s1.run();
        s2.run();//两个都是run(),执行哪个呢，就看左边的类型了，如果父类和子类都有时，该方法就执行子类的，

    }
}

instanceof和类型转换

instanceof (类型转换) 引用类型，判断一个对象是什么类型，判断两个类之间是否存在父子关系，

package aaa.demo01;

public class Application {
    public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();

        //System.out.println(X instanceof  Y);  //能不能编译通过！

        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);   //编译报错！
        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);  //编译报错！
        //System.out.println(person instanceof String);   //编译报错！
    }
}

package aaa.demo01;

public class Application {
    public static void main(String[] args) {
        //类型之间的转换；  父   子

        //子类转换为父类，可能丢失自己的本来的一些方法
        Student student = new Student();
        student.go();
        Person person =student;
        //person.go;    //走不了 了
    }
}

package aaa.demo01;

public class Student extends Person{

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

package aaa.demo01;

public class Person {


}

package aaa.demo01;

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();//向下转型
    }
}