Java面向对象编程

最新推荐文章于 2024-01-18 21:18:10 发布

巫山123qwe

最新推荐文章于 2024-01-18 21:18:10 发布

阅读量298

点赞数

文章标签： java servlet 开发语言

本文链接：https://blog.csdn.net/buqinbuchu/article/details/127891475

版权

面向对象思想

类以物聚，分类的思维模式。适合处理复杂的问题，适合多人协作。

对于描述复杂的事物，要宏观上把握整体合理分析，微观操作还是要面向过程。

以类的方式组织代码，以对象的形式封装数据。

抽象

三大特性

封装
继承
多态

方法的回顾及加深

方法的定义

修饰符
返回类型
break；跳出循环，结束循环
return；结束方法，返回一个值
方法名
参数列表
异常抛出

方法调用

静态方法
非静态方法
形参和实参
值传递和引用传递
this关键字

类和对象的关系

类

类是一种抽象的数据类型，他是对某一类事物整体描述/定义，但不是代表某一个具体的事物。

对象

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

创建与初始化对象

使用new关键字创建对象

构造器必须掌握

类与对象

package com.xujinchen.pop.Demo02;

public class Person {
    //一个类即使什么都不写，它也会存在一个方法
    //显示定义的构造器
    String name;
    int age;
    //实例化初始值
    //1,使用new关键字，本质是在调用构造器


    public Person() {
    }

    //有参构造,一旦定义了有参构造，无参就必须显示定义
    public Person(String name){
        this.name=name;
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
/**
 *     public static void main(String[] args) {
 *         //new实例化了一个对象
 *        Person person = new Person("xujinchen");
 *         System.out.println(person.name);//xujinchen
 *
 *     }
 *
 *     构造器；
 *     1.和类名相同
 *     2.没有返回值
 *     作用
 *     1.new本质是在调用构造方法
 *     2.初始化对象的值
 *     注意点
 *     1.定义了有参构造，如果想使用无参构造,无参就必须显示定义
 *
 *     Alt+insert
 */


类是一个模板，抽象，对象是一个具体实例，

方法定义，调用

对应的引用

  引用类型；；八大基本类型除外的  
  对象是通过引用来操作；栈----->堆

对象的属性；字段field成员变量

     默认初始化；  
     数字；0   0.0  
     char；  u0000  
     boolean；    false  
     引用； null  
     修饰符   属性类型    属性名 =属性值

对象的创建和使用

     必须使用new关键字创造对象，还要有构造器   Person xu = new Person();  
     对象的属性  xu.name  
     对象的方法   xu.sleep()  

package com.xujinchen.pop.Demo03;

public class Pet {
    public String name;
    public int age;
    public void shout(){
        System.out.println("叫了一声");
    }
}
/**
 * package com.xujinchen.pop;
 *
 * import com.xujinchen.pop.Demo03.Pet;
 *
 * public class Application{
 *     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);
 *
 *     }
 * }
 *
 *
 *
 *
 */

类

     静态的属性   属性  
     动态的方法  
     封装   继承  多态

封装

private类和get、set方法

package com.xujinchen.pop.Demo04;
//类   private;私有
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 getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age<120 && age>0){//不合法的

            this.age = age;
        }else {

            this.age = 3;
        }

    }

    public int getId() {
        return id;
    }

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

    //睡觉()
}
/*
 package com.xujinchen.pop;


1.提高程序的安全性，保护数据
2.隐藏代码的细节
3.统一接口
4.提高系统可维护性

import com.xujinchen.pop.Demo04.Student;

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

        s1.setAge(99);//不合法
        System.out.println(s1.getAge());
    }
}


 */

继承

继承的本质是对某一批类的抽象，从而实现对现实世界的建模
extends的意思是“扩展”，子类是父类的扩展。
java中的类只有单继承，没有多继承
类之间还有依赖，组合，聚合等关系
object类

package com.pop.Demo05;

import java.util.Objects;

//Person 人
//在java中所有的类都默认继承object
public class Person{
public void say(){
System.out.println(“说了一句话”);
}
//public 公共
//protected 受保护的
//default 默认
//private 私有
public int money =10_0000;
}
super - this

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.父类的功能，子类不一定需要，或者不一定满足！
2.Alt+insert；override；

重写；需要有继承关系，子类重写父类的方法！
1. 方法名必须相同
2. 参数列表必须相同
3. 修饰符范围可以扩大；但是不可以缩小；public > protected > default > private
4. 抛出异常：范围可以被缩小，但不能扩大；ClassNotFoundException —>Exception(大)
重写；子类的方法和父类的方法必须要一致；方法体不同！

为什么要重写；
1.父类的功能，子类不一定需要，或者不一定满足！
2.Alt+insert；override；

多态

即同一种方法可以可以根据发送对象不同而采取多种不同的行为方式

一个对象的实际类型是确定的，但可以指向对象的引用类型有很多

多态存在的条件

有继承关系
子类重写父类方法
父类引用指向子类对象

注意

多态是方法的多态，属性没有多态
instanceof   （类型转换） 引用类型
父类和子类，有联系 类型转换异常！   ClassCastException
    1. static 方法，属于类，不属于实例
    2. final  常量；
    3. private方法；

我的gitee仓库https://gitee.com/cncw-bbac/basic-grammar-1