java_02面向对象

最新推荐文章于 2021-12-06 08:32:23 发布

胖虎艾春辉

最新推荐文章于 2021-12-06 08:32:23 发布

阅读量148

点赞数

分类专栏：学生 java 文章标签： java_02面向对象

本文链接：https://blog.csdn.net/weixin_42479155/article/details/88616118

版权

学生同时被 2 个专栏收录

112 篇文章 0 订阅

订阅专栏

java

91 篇文章 1 订阅

订阅专栏

编程思想
1. 面向过程思想，解决问题的时候按照一定的过程，以过程为本，复用性低，增加很多冗余
2. 面向对象的编程思想，按照实体的特点进行解决问题，复用性高，实体是动作的支配者
类和对象：
1. 类，抽象笼统的概念，描述一类事物，肯定是具有相同的特征行为

2. 对象，一个具体的事物，事物的支配者

public class TestClass {
//这个文件是为了描述计算机中人类长什么样子
public String name;
public int age;
public String sex;

public static void main(String[] args) {
    //创建一个对象，找一个空间来存储
    //类型是TestClass类型，是一个引用类型
    TestClass p = new TestClass();//通过对象去调用属性
    p.name = "张三";
    p.age = 18;
    p.sex = "男";
    System.out.println(p.name+p.age+p.sex);
}

}

[外链图片转存失败(img-YGkQgAlG-1562333045621)( 在这里插入图片描述 ])

类中的方法

权限修饰符【特征修饰符】返回值类型方法名字（参数列表）【抛出异常】【{ 方法体 }】
每一个类中不是必须包含主方法的，主方法不属于任何一个类，主方法属于虚拟机jvm

传递的值不是地址，无法进行值的修改，也就是说，并不能改变主程序中传递变量的值，相当于形参与实参的传递问题

public class function {
    public void ChangeNum(int x){
        System.out.println("方法开始执行");
        x=10;//修改传递参数
        System.out.println("方法执行完毕");
    }

    public static void main(String[] args) {
        function t = new function();
        int a = 1;
        t.ChangeNum(a);
        System.out.println("方法执行完毕"+a);
    }
}
函数运行结果得到的是1

![2019-03-04 20-02-05 的屏幕截图] 在这里插入图片描述 )

类的方法存储在堆内存的内存空间里面，方法执行在栈内存，在栈内存中临时开辟一个空间执行方法
将两个数组进行交换，最笨的方法是进行单个元素的赋值，最好的方法是进行地址的交换，因为我们可以理解，数组在栈内存储存的是地址，地址指向堆内存里面的内存空间

数组遇到的问题：

public class function {
    public void ChangeArray(int[] x,int[] y){
        int [] temp;
        temp = x;
        x = y;
        y = temp;
    }

    public static void main(String[] args) {
        function t = new function();
        int[] a = new int[]{1,2,3,4};
        int[] b = new int[]{5,6,7,8，9};
        t.ChangeArray(a,b);
        for (int n:a) {
            System.out.print(n + " ");
        }
        System.out.println();
        System.out.println("-------------");
        for (int n:b) {
            System.out.print(n + " ");
        }
    }
}
运行结果：
1 2 3 4 
-------------
5 6 7 8 9
Process finished with exit code 0

为什么会有上面的错误呢:

-[外链图片转存失败(img-9BRZPzpo-1562333045621)( 在这里插入图片描述 ])

上图表示了交换过程，因为没有返回值，导致x和y是地址不会改变的，改进方法：

public class function {
    public int[][] ChangeArray(int[] x,int[] y){
        int [] temp;
        temp = x;
        x = y;
        y = temp;
        int[][] result = {x,y};
        return result;
    }

    public static void main(String[] args) {
        function t = new function();
        int[] a = new int[]{1,2,3,4};
        int[] b = new int[]{5,6,7,8,9};
        int [][] c =t.ChangeArray(a,b);
        a = c[0];
        b = c[1];
        for (int n:a) {
            System.out.print(n + " ");
        }
        System.out.println();
        System.out.println("-------------");
        for (int n:b) {
            System.out.print(n + " ");
        }
    }
}

命名规则和规约：最好名字都要见名思意
1. 字母数字符号中文(不推荐使用)，字母不区分大小写，数字不能开头，符号就只有_和$
2. 类名字，首字母大写，两个单词以上，每个首字母都要大写
3. 属性/方法/变量驼峰式的命名规约，注意方法也是驼峰式
4. 静态常量全部字母大写通过_做具体说明 BOOKSTORE_ADMIN
5. 包名全部字母小写，注意不能与关键字进行冲突

overload 方法重载

一个类中的一组方法，相同的方法名字，不同的参数列表，输出不同的结果
作用：为了让使用者便于记忆和使用，提高使用效率
参数的个数，参数的类型，参数的顺序不同

在新版本的时候一个新写法

    public void test(int... x){}个数是动态列表，认为是相当于varchar相似的表现
    这里的x是数组
    动态列表的方法不能和相同意义的数组进行重组，动态列表的参数可以不传，数组的参数不能不传
    动态参数列表在方法的参数中只能存在一份儿，必须放在方法参数末尾

构造方法

作用：构建当前类的对象、
默认存在，每一个类都有构造方法，如果用户没有定义方法，系统会默认提供一个构造函数
this关键字的使用，是一个关键字，代替的是某一个对象，当前调用属性或者方法时的那个对象，认为构造方法早于一般方法，不能在一般方法内调用构造方法，在一个构造方法内可以调用另一个构造方法，通过this()，省略了类名，必须在程序的第一行，不一定是当前类的对象
程序块（代码块)，可以理解为一个无参数无返回值无名的方法，跟普通方法一样，{代码}，如何调用方法，在每一次我们调用构造方法之前，系统会帮我们自动的调用一次程序块，也就是说，这代码块的调用在构造函数之前，但是可以在类中调用多个块，块可以写一些程序，想要在构造方法之前

继承

子类继承父类，extends
子类的对象以调用父类中(public protected)属性和方法
子类可以添加一些独有的方法

子类从父类中继承过来的方法不能满足子类需要，可以在子类中重写（覆盖）父类的方法，更多指的是内容

final static abstract
父类方法是final 子类不能重写
父类方法是static 子类不存在
父类方法是abstract 子类必须重写，如果子类是具体必须重写，否则子类是抽象类，可以不重写

每一个类都有继承类，如果不写extends关键字，默认继承object，如果写了extends则继承后面那个父类，可以理解为object类非常重要，是任何一个引用类型的父类（直接或间接的继承object）object类没有父类
```
几个需要使用的object类方法：
wait() 线程进入挂起等待状态
notify() 线程唤醒
notifyAll() 唤醒所有线程
getClass() 获取类映射
clone()  protected修饰符，将对象拷贝
```
我们可以通过传递的方式实现多继承效果
子类的构造方法执行之前，会回溯父类的构造方法[外链图片转存失败(img-gc21Un8l-1562333045622)(])
this 代替的是当前调用方法时的那个对象，不一定是当前类的对象，super代替的是当前执行类的对象的父类对象，子类构造方法中默认有一行代码super，调用父类方法，但是this和super在构造方法中调用另一个类的构造方法不能同时出现在第一行，构造方法中不能来回调用
程序块严格意义来说，不算子类继承过来，程序块子类不能直接调用，子类执行构造方法之前默认调用了父类的构造方法，父类构造方法之前执行

类的包含关系（组合聚合关联）

组合：整体和部分关系，不可分割
聚合：整体和部分关系，创建时候有可能是分开的
关联：整体和部分关系，可以分割，后来形成一起

从java程序来描述这样的关系，通过一个类当做另一个类的属性进行存储

package java学习;

public class Wheel {
    public String brand;
    public  int size;
    public String color;
    public void  turn(){
        System.out.println("车轮子会转动");
    }
}
package java学习;

public class Car {
    public String brand;
    public String type;
    public String color;
    public Wheel wheel;
    public void showCar(){
        System.out.println("这是一辆车");
        System.out.println(wheel.brand);//wheel是引用数据类型，需要进行赋值
        wheel.turn();
    }
}
package java学习;

public class jicheng {
    public static void main(String[] args) {
        Car car = new Car();
        car.wheel = new Wheel();
        car.wheel.brand="米其林";
        car.wheel.size = 400;
        car.wheel.color = "酷黑";
        car.showCar();

    }
}

依赖关系

包含不能表示的关系 – 屠夫杀猪（依赖关系）
不是整体和部分的关系，是因为某一件事情产生了关系，临时组合在一起，这件事情一旦关系完成就解散
设计类的关系：高内聚低耦合，耦合度：继承》包含》依赖
java程序形式为：一个类的方法中使用到了另一个类的对象

修饰符

权限修饰符：public protected private
特征修饰符：final(最终的不可更改的) static(静态的) abstract(抽象的) native(本地的) transient(瞬间的，短暂的)synchronized(同步的) volatile(不稳定的)
final 最终的，不可更改的，可以修饰变量(一旦变量被修饰了，无法再次被更改)，理解就是锁住栈内存中的空间变量，如果修饰的变量是引用数据类型，只是地址不能更改，但是值还是能更改的
final修饰属性，全局变量，存储在堆内存中对象空间的一个空间，属性用final修饰，必须赋值初始值,一般工具类是用final进行修饰，无法被继承;修饰方法，方法不能被子类重写
static 静态的 abstract抽象的
static修饰属性，方法，修饰块，修饰类(内部类)
1. 修饰属性时候，这个属性放置在单独的地方，放在存储区的静态元素区
2. 静态元素只有一份，给所有子类共享
3. 静态元素是属于类的不属于任何一个对象
4. 内存管理：栈内存创建开始，用完回收堆内存gc回收静态元素区是常驻内存
5. 非静态成员可以访问静态成员，但是静态成员不可以访问非静态成员
6. 静态元素属于类，静态元素中不可以出现this或者super关键字

设计模式

用来解决某些场景下的某一类问题—> 通用的解决方案
创建型模式–用来解决对象创建的过程（单例模式工厂方法模式抽象工厂模式建造者模式原型模式）
1. 单例模式：比如百度服务器的调用方法，不会给每个用户都进行类实例化
```
1. 私有的构造方法
2. 私有的静态的当前类对象作为属性
3. 公有的静态的方法返回当前类的对象
```
结构型模式–把类或对象通过某种形式结合在一起，构成某种复杂或合理的结构（适配器模式装饰者模式代理模式外观模式桥接模式组合模式享元模式）
行为型模式-- 用来解决类或对象之间的交互，更合理的优化类或者对象之间的关系（观察者模式策略模式模板模式责任链模式解析器模式迭代子模式命令模式状态模式备忘录模式访问者模式中介者模式）
类的加载机制：
1. 父类的类模板
2. 父类的静态空间
3. 默认执行父类的块
4. 加载子类的类模板
5. 加载子类的静态空间
6. 默认执行子类的块
7. 申请开辟子类对象空间

抽象类和抽象方法、接口

没有具体的执行，只是一个概念
用abstract修饰符修饰的方法，只有方法的结构，没有方法执行体，叫做抽象方法
用native修饰的方法虽然也没有方法体，但是不是抽象方法，只是执行过程是其他语言
用abstract修饰符修饰的类，叫做抽象类，抽象类中不是必须含有抽象方法中，抽象方法方法抽象类或者接口中
抽象类含有构造方法，但是我们不能通过调用构造方法直接创建对象，只能通多子类来进行使用
抽象类可以直接单继承抽象类，抽象类可以单继承一个具体类，但是通常不会实现，具体类不可以直接单继承抽象类（而是通过将父类的抽象方法具体化，也可以让子类缓存抽象类）
，如果抽象类里面没有具体成员，全部都是抽象方法，那么它就是一个接口，但是接口不能用class修饰，改用interface修饰
接口：
1. 属性中：不能含有一般属性只能含有公有的静态常量 public static final默认
2. 方法：不能含有一般的方法，只能含有公有的抽象的方法（但是发展了default修饰具体方法）
3. 构造方法：不能汉语构造方法
4. 只能通过子类多实现implements
5. 抽象类可以直接多实现接口，具体类不可以直接多实现接口，必须将接口的抽象方法具体化，或是具体类转化为抽象类
6. 接口可以多继承接口
  [外链图片转存失败(img-Uk3knS0S-1562333045622)(/])
举个例子：

英雄- 抽象类

坦克法师刺客射手等