Java面向对象

Z_hang_JJ

已于 2023-07-17 17:32:15 修改

阅读量64

点赞数

文章标签： java 开发语言

于 2023-07-12 00:06:36 首次发布

本文链接：https://blog.csdn.net/Z_hang_JJ/article/details/131661000

版权

java面向对象

1. 面向过程和面向对象的区别

面向过程的设计思想（Procedure -Oriented Programming），简称POP。
关注的重心是过程，中心思想是减少代码的冗余代码，便于维护，于是以创建函数作为解决方法。
典型的语言：C语言。
是一种执行者思维，适合解决简单问题，但是扩展能力差，后期维护难度大。
面向对象的设计思想（Object Orinented Programming），简称OOP。
关心的重心的”类“，中心思想是参照现实事物，将事物的属性特征和行为特征抽象出来，用类来表示。
典型的语言：Java，C#，C++，Python等。
是一种设计者思维，适合解决复杂问题。代码扩展性高，维护难度低。

总而言之:

面向过程就是更着重于全局的过程,程序自上而下来逐步解决问题,就像冰箱里装大象,面向过程的步骤就是人把冰箱打开,然后把大象放进去,再关上冰箱.
对于面向对象来说,程序更着重于建立不同的对象,在对象的角度上来分段解决问题.例如把大象装进冰箱,就是人是一个对象,人要做的就是把冰箱打开,把冰箱关上,把大象拿着.大象要做的是进入冰箱,冰箱要做的打开和关闭.而类是一类对象的一种总称,对象是类的实例,就像我们不仅仅可以是人把大象放进冰箱,在同一类中,也可以是人把猴子放入冰箱,猴子把大象放入冰箱,人把大象放入房子等操作.
选择了面向对象,后期如果要解决问题可以从每个对象中入手,而不牵扯到其他对象,就像人把大象放入冰箱,有时候可能冰箱上锁了,那么就得给人这个对象加一步用锁开锁的方法,而对于面向过程来说,就得从头到尾来找到人把大象放入前的地方来把打开冰箱这一操作加进去,有时候可能代码过长,以至于找到这部分代码不是一个简单地事情.但是对于面向对象来说,只需找到相应的对象,然后向该对象后再添加一个方法即可.

2.类和对象

类的结构
变量：事物的属性
方法：事物的行为
块：没名称的代码块
构造方法：初始化对象
内部块：类中声明的类
对象的意义
对象是类的实例化表现
接下来给出一段代码来诠释类的结构与类与对象的关系

public class CsdnClass {
    static{}//静态块
    public CsdnClass(){}//构造方法
    public static void method1(){}//静态方法（调用不需要实例化对象，直接使用类名+方法名就可以调用）
    public static int x;//静态变量
    public void method2(){}//非静态方法（必须要创造对象才可以使用）
    public int y;//非静态变量
    {}//代码块

    public static void main(String[] args) {
        CsdnClass cs=new CsdnClass();//创建一个实例化对象
        cs.method2();//非静态方法的调用
        CsdnClass.method1();//静态方法的调用
        int x=CsdnClass.x;//静态变量的调用
        int y=cs.y;//非静态变量的调用

    }
}

*其中的静态块是当程序开始加载时便运行
而块和构造方法是当实现对象后自动运行的
当没有自定义构造方法时，系统会自动构建一个默认的构造方法，当自定义一个构造方法后，默认的构造方法消失。*

注:关于关键词this的各项特征及实例:

this代表的是当前对象
this用来代表引用成员变量.
this用来代表引用成员方法或者构造方法,如何调用可以看下方代码

public class Demo1 {
    public int num1;
    public String name;
    public static int piece;
    public Demo1(String name,int num1){
        this.name=name;
        this.num1=num1;
    }
    public Demo1(){
        this("asf",8);
    }
    public void eat(){
        System.out.println("正在吃");
    }
    public void activity(){
        eat();
    }

    public static void main(String[] args) {
        Demo1 demo1=new Demo1("zjj",21);
        Demo1 demo2=new Demo1();
        System.out.println(demo1.name);
        System.out.println(demo2.name);
    }
}

3.关键词static和代码块的解释

static对于方法/变量的调用（只需使用类名+方法名/变量名便可使用）

public class TacketSeller {
    //定义一个公开的静态变量
    public static int ticket=10;
    public static void sellTicket(){
        ticket=ticket-1;
        System.out.println("卖票的方法");
    }
    public static void main(String[] args) {
        TacketSeller.sellTicket();
    }
}

代码块：分为静态块和实例块：
静态块：与是否创建对象无关，类加载时候自动调用，仅调用一次。
实例块：每次创建对象时自动调用。

4.包

包（package）的背景：随着程序框架的越来越大，类的数量越来越多，这时候发现系统的维护难度越来越大，于是产生了包。
使用关键词package来命名包。
包要避免重名。
一个类的完整写法是包名+类名。
在一个类中调用不同的包要用关键词import，但是java.lang包比较特殊，使用时不需要导入。

5.访问权限修饰符

public：公共权限，可以在任意类中访问。
private：私有权限，只可以在同一类中访问，不修饰类。
protected：受保护的权限，可以在同包内被访问，若不是同包，则必须要是该类的子类才能访问，不修饰类。
default：默认的同包权限，可以在同包内被访问。
如图：

6.面向对象的特征
面向对象语言有三大特征：
封装
继承
多态

（1）面向对象特征------封装：

封装的概念及意义：
将类的某些信息隐藏在类的内部，不允许类外部直接访问，而是要通过该类提供的方法进行访问。可以隐藏类的信息并且控制语句更加方便。
封装的方式：
使用不同的操作权限：
用来封装类中的成员变量

public class Demo1 {
    private String name;
    //使用getName来得到该类中成员变量改变后的值,但是类中的成员变量本质上是不变的,只是其所对应的对象中调用的成员变量的值变化
    public String getName(){
        return name;
    }
    //使用setName方法来改变调用的对象中的成员变量
    public void setName(String name){
        this.name=name;
    }
    void judge(){
        System.out.println(name);
    }

}
public class Demo2 {
    public static void main(String[] args) {
            Demo1 demo1=new Demo1();
            //改变demo1对象的Demo1中模板的成员变量的值
            demo1.setName("张三");
            //用来得到模板中成员变量的值
            String name=demo1.getName();
            demo1.judge();
    }
}

对于类中构造方法的封装:

public class Demo3 {
     public static Demo3 demo3=null;
    //对构造方法进行封装
    private Demo3(){

    }
    public static Demo3 setDemo3(){
        if(demo3==null){
            demo3=new Demo3();
        }
        return demo3;
    }
    public void test(){
        System.out.println("封闭构造方法怎么用");
    }
}
public class Demo4 {
    public static void main(String[] args) {
        Demo3 demo3=Demo3.setDemo3();
        demo3.test();

    	}
    }

（2）成员变量和局部变量的区别：

成员变量：在类中定义局部变量：在方法中定义或充当方法的参数
成员变量可以使用权限修饰符局部变量不能使用
成员变量创建对象后用构造方法初始化，局部变量必须定义，赋值进行初始化
成员变量随着对象的创建而存在，随着对象的销毁而消失。局部变量随着方法的调用而存在，随着方法的调用完毕而销毁
成员变量与对象一起在堆内存中，局部变量存在于栈中

（3）继承

为什么要继承？
继承的出现减少了代码的冗余，提高了代码的复用性。
继承的出现，有利于功能的扩展。
继承为之后多态的出现作了铺垫。
对于继承的语法：
通常会用到extends，super，this等

public class Animal {
    public String name;
    public static String name1;
    public String color;
    public int old;
    public Animal(String name,String color,int old){
        this.name=name;
        this.color=color;
        this.old=old;
    }
    public void eat(){
        System.out.println(name+"正在吃食物");
    }
    public void play(){
        System.out.println(name+"正在玩球");
    }
    public static void dirnk(){
        System.out.println();
    }

    public static void main(String[] args) {
        Animal dou=new Dogs("1","1",1);//将该对象提升到了父类（只能使用父类中的方法）
        dou.eat();
        //不能够使用dou.getPut(将对象提升到父类后子类函数失效)
    }
}
public class Cats extends Animal {
    public Cats(String name,String color,int old){
        //调用父方法中的构造方法
        super (name, color, old);
    }
    private void getPut(String name,String color,int old){
        System.out.println("小猫的名字是"+name);
        System.out.println("小猫的颜色是"+color);
        System.out.println("小猫今年"+old+"岁了");
    }

    public static void main(String[] args) {
        Cats cat1=new Cats("Mike","red",2);
        cat1.getPut(cat1.name, cat1.color, cat1.old);
        cat1.eat();
        cat1.play();
    }

}

由父类到子类的继承：
继承可以进行多层继承，一个父类也可以同时拥有多个子类，但是java中子类的继承不支持多重继承。
java.long.Object是类层次结构的根类，即所有类的父类。当一个类没有显示继承其他的类的时候，则自动继承Object类。
方法的重写（Override）
子类重写的方法必须和父类中的方法名称相同，参数列表相同，返回值相同
子类重写的方法访问权限不能小于父类方法的访问权限
父类的私有方法不能被重写
super的用法
super可以调用父类中定义的属性和成员方法。
当子类和父类中出现同一命名的成员时，super指的是父类，this指的是子类。

（4）多态

多态的概念：当两类存在继承关系时，父类引用指向子类的对象，即形成多态。
创建了一个子类的对象，但是方法的形式参数是父类的类型，这时候对象所调用的方法是子类中的方法。
如果调用的静态成员方法，那么调用的就是左边父类的成员方法。
向下转型：

父类名+父类变量名=new 子类名（）
//将父类变量名强制转换为子类变量，使其可以使用父类成员方法，也可使用子类成员方法
子类名称+子类变量名=（子类名）父类变量x；

7.接口

接口是一种特殊的抽象类，这中抽象类中包括抽象方法
使用interface关键词来声明一个接口

例如：public interface method extends 其他的接口1，......其他的接口n

接口的使用：
使用implements关键词来实现接口

public class 类名 implements 接口名1，接口名2{}

接口不能实例化对象。
接口是隐式抽象的，主要来定义功能。

Z_hang_JJ

关注

0
点赞
踩
0

收藏

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

【代码】Java面向对象。
复制链接

扫一扫