Java学习笔记6

最新推荐文章于 2024-03-19 18:08:05 发布

zxgt5y

最新推荐文章于 2024-03-19 18:08:05 发布

阅读量47

点赞数

分类专栏：笔记

本文链接：https://blog.csdn.net/zxgt5y/article/details/118939529

版权

笔记专栏收录该内容

44 篇文章 0 订阅

订阅专栏

Java学习笔记6

面向对象编程

面向过程 & 面向对象

面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么…
- 面对过程适合处理一些较为简单的问题
面向对象思想
- 物以类聚分类的思维模式，思考问题首先会解决问题那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
- 面向对象适合处理发杂的问题，适合处理需要多人协作的问题
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理

什么是面向对象？

面向对象编辑的本质就是：以类的方式组织代码，以对象的组织(封装)数据
抽象
三大特征
- 封装
- 继承
- 多态
从认识的角度考虑是现有对象后有类。对象，是具体的事务。类，是抽象的，是对对象的抽象
从代码运行角度考虑是先有类后有对象。类是对象的模板

回顾方法及加深

方法的定义
- 修饰符
- 返回类型
- break：跳出switch，结束循环和 return 的区别
- 方法名：注意规范见名知意
- 参数列表：(参数类型，参数名)…
- 异常抛出：疑问
方法的调用
- 静态方法
- 非静态方法
- 形参和实参
- 值传递和引用传递
- this关键字

类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
- 能够体现出特点，展现出能力的是具体的实例，而不是一个抽象的概念

创建与初始化对象

使用new关键字创造对象
使用new关键字创造的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用

public class Student {
    String name;
    int age;
    public void study(){
        System.out.println(this.name+"正在学习");
    }
}

public class Application {
    public static void main(String[] args) {
        Student xm=new Student();
        Student xh=new Student();
        xm.name="小明";
        xh.name="小红";
        xm.age=3;
        xh.age=3;
        System.out.println(xm.name);
        System.out.println(xh.name);
        System.out.println(xm.age);
        System.out.println(xh.age);
    }
}

构造器

一个类即使什么都不写，它也会存在一个方法
使用new关键字，本质是在调用构造器
一旦定义了有参构造，无参就必须显示定义
alt + insert 快捷键

public class Demo7 {
    String name;
    public Demo7() {
    }
    public  Demo7(String name){
        this.name=name;
    }
}

public class App7 {
    public static void main(String[] args) {
        Demo7 demo7= new Demo7("zxgtwy");
        System.out.println(demo7.name);
    }
}

类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
小结类与对象
- 类与对象
  
  类是一个模板：抽象，对象是一个具体的实例
- 方法
  
  定义，调用
- 对应的引用
  
  引用类型：基本类型(8)
  
  对象是通过引用来操作的：栈–》堆
- 属性：字段field 成员变量
  
  默认初始化：
  
  数字： 0 0.0
```
char     ：   u0000
```
  boolean ： false
  
  引用： null
  
  修饰符属性类型属性名 = 属性值
- 对象的创建和使用
```
1. 必须使用new关键字创造对象， 构造器    Person  p=new Person（）；
2. 对象的属性     p.name
3. 对象的方法    p.sleep（）
```
- 类：
  
  静态的属性属性
  
  动态的行为方法

封装

该露的露，该藏的藏
- 我们程序要追求**”高内聚，低耦合“**。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；第耦合：仅暴露少量的方法给外部使用
封装(数据的隐藏)
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏
属性私有，get/set

public class Student {
    private String name;
    private  int age;
    private char sex;

    public String getName() {
        return name;
    }
    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;
        }
    }
}

public class Applicaton {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("奥特曼");
        System.out.println(s1.getName());
        s1.setAge(-1);
        System.out.println(s1.getAge());
    }
}

作用：
1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增加了

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
extends的意思是"扩展"。子类是父类的扩展
Java中类只有单继承，没有多继承
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
继承关系的俩个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该有“is a”的关系
object类
super ：
1. super调用父类的构造方法，必须在构造方法的第一个
2. super必须只能出现在子类的方法或者构造方法中
3. super和this不能同时调用构造方法
私有的东西无法被继承

super VS this	代表对象	前提	构造方法
super	代表父类对象的应用	只能在继承条件才可以使用	父类的构造
this	本身调用者这个对象	没有继承也可以使用	本类的构造

重写

方法重写需要有继承关系，子类重写父类的方法

方法名必须相同
参数列表必须相同
修饰符：范围可以扩大但不能缩小： public > Protected > Default > private
子类的方法和父类必要一致：方法体不同
抛出的异常：范围可以被缩小，但不能被扩大：

ClassNotFoundException–> Exception(大)

为什么要重写？

父类的功能，子类不一定需要，或不一定满足

Alt + Insert ： override ；
静态方法：方法的调用只和左边，定义的数据类型有关
非静态：重写

多态

即同一方法可以跟根据发送对象的不同而采用多种不的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多(父类，有关系的类)
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性
static 方法，属于类，不属于实例，不可重写，无多态
final 常量不可重写，无多态
private 方法，不能重写，无多态

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

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

public class Application {
    public static void main(String[] args) {
        Student s1=new Student();
        Person s2=new Student();
        //对象能执行哪些方法，主要看左边的类型，和右边关系不大
        s2.run();
        s1.eat();
        ((Student)s2).eat();
    }
}

instanceof 和类型转换

instanceof 可以判断两者是否有父子关系
父类引用指向子类的对象
把子类转换为父类，向上转型，可能会丢失自己的本来的一些方法
把父类转化为子类，向下转型，强制转换
类型转换可以**方便方法的调用，减少重复的代码

static关键字以及抽象类

静态代码块，只执行一次，随后先执行匿名代码块后执行构造方法
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明抽象类
抽象类不能使用new关键字来创建对象，它是用来让子类继承的
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

public abstract class Action {
    public abstract void doSomething();
}

接口

普通类：只有具体实现
抽象类：具体实现和规范都有
接口：只有规范！自己无法写方法~专业的约束
接口就是规范，定义的是一组规则，体现了显示世界中“如果你是…则必须能…”的思想
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守
OO的精髓，是对对象的抽象，最能体现这一点的就是接口。
声明类的关键字是class，声明接口的关键字是interface
public abstract 方法 public static final 常量
接口不能被实例化，接口中没有构造方法
implements可以实现多个接口
实现接口必须重写接口中的方法
利用接口可以实现多继承

public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {

    }
    @Override
    public void delete(String name) {

    }
    @Override
    public void update(String name) {

    }
    @Override
    public void query(String name) {

    }
    @Override
    public void time() {
        
    }
}

public interface TimeService {
    void time();
}

public interface UserService {
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

内部类

内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对于B类来说就是外部类了
成员内部类
静态内部类
局部内部类
匿名内部类

public class Application {
    public static void main(String[] args) {
        Outer outer =new Outer();
        Outer.Inner inner =outer.new Inner();
        inner.in();
        inner.getID();
    }
}

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
        public void getID(){
            System.out.println(id);
        }
    }
}

内部类可以获得外部类的私有属性，通过外部类来实例化内部类
一个Java类中可以有多个class类，但是只能有一个public class 类

异常

检查性异常：无法预见
运行时异常：可以在编译时被忽略
错误(ERROR)
Java可以把异常当作对象处理，并对以一个基类java.lang.Throwable作为所有异常的超类
分为两大类，Error和Exception

Error

Error类对象有Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关
Java虚拟机运行错误(Virtual MachineError)，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机一般会选择线程终止
还有发生在虚拟机试图执行应用时，如类定义错误，连接错误。这些错误是不可查的，因为它们在应用车徐的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的情况

Exception

在Exception分支中有一个重要的子类RuntimeException(运行时异常)
这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生
Error和Exception的区别：Error通常时灾难性的致命错误，时程序无法控制和处理的，当出现这些异常时，Java与你及一般会选择终止线程；Exception通常情况下时可以被程序处理的，并且在程序中应该尽可能的去处理这些异常

异常处理机制

抛出异常
捕获异常
异常处理五个关键字
- try 监控区域
- catch 捕获异常
- finally 处理善后工作
- throw 主动的在方法里面抛出异常
- throws 在方法上抛出异常
Ctrl + Alt + T 快捷键

自定义异常

使用Java内置的异常类可以描述在编程时出现的大部分异常情况。用户自定义异常类，只需继承Exception类即可
在程序中使用自定义异常类，大体可分为以下几个步骤：
1. 创建自定义异常类
2. 在方法中通过throw关键字抛出异常对象
3. 如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作
4. 在出现异常方法的调用者中捕获并处理异常

实际应用中的问题总结

处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
在多重catch块后面，可以加一个catch来处理可能会被遗漏的异常
对于不确定的代码，也可以加上try-catch，处理潜在的异常
尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
尽量添加finally语句块去释放占用的资源

zxgt5y

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习笔记6

Java学习笔记6面向对象编程面向过程 & 面向对象面向过程思想步骤清晰简单，第一步做什么，第二步做什么…面对过程适合处理一些较为简单的问题面向对象思想物以类聚分类的思维模式，思考问题首先会解决问题那些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索面向对象适合处理发杂的问题，适合处理需要多人协作的问题对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向
复制链接

扫一扫