JAVA面向对象编程的思想

weixin_51454889

已于 2022-05-19 08:19:46 修改

阅读量365

点赞数 2

分类专栏： JavaSE 文章标签： java

于 2022-03-30 15:38:41 首次发布

本文链接：https://blog.csdn.net/weixin_51454889/article/details/123848005

版权

JavaSE 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

面向对象编程

什么是面向对象？

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

三大特性

封装

继承

多态

方法调用

1.静态方法

可直接调用（和类一起加载）

2.非静态方法

需要实例化这个类（类实例化之后才存在）

3.引用传递

传递的是一个对象(可见 Hero.java)


public class Person_test {
public static void main(String[] args) {
Person new_person = new Person();
System.out.println(new_person.attack);
Person_test.rename(new_person);
System.out.println(new_person.attack);
}
public static void rename(Person people){
people.attack="章茂淳";
}
}
class Person{
String attack;
}

构造器

一个类即使什么都不写，它也会存在一个方法（无参构造器）

构造器的作用

1.实例化初始值

public class Hero {
    public static void main(String[] args) {
        Yasuo gamer1 = new Yasuo();

        System.out.println(gamer1.Bigname);
        System.out.println(gamer1.name);
        System.out.println("---------------");

        Yasuo gamer2 = new Yasuo("Q",2);
        System.out.println("Q技能为"+gamer2.HeroSkills_Q);

    }
}

class Yasuo{
    String Bigname;
    String name;

    String HeroSkills_Q;
    //显示的定义构造器
    //实例化初始值
    //1.使用new关键字，本质是在调用构造器
    public Yasuo(){
        this.Bigname="疾风剑豪";
        this.name="亚索";
    }

    //有参构造：一旦定义了有参构造，无参构造必须显示定义
    public Yasuo(String directive,int gamer){
        if(directive=="Q"){
            HeroSkills_Q="斩钢闪";
            System.out.println("玩家"+gamer+"使用英雄：疾风剑豪—亚索，释放了Q技能：斩钢闪");
        }
    }

    //alt+insert  idea快捷键生成构造器
}

创建对象内存分析

在这里插入图片描述

封装

高内聚，低耦合

高内聚：就是类的内部数据操作细节自己完成，不允许外部干涉；

低耦合：仅暴露少量的方法给外部使用

package com.面向对象编程;

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

public class encapsulation {

    //属性私有
    private String name;
    private int age;
    private char sex;

    //提供一些可以操作这个属性的方法
    //提供一些public的get、set方法
    public String getName(){
        return this.name;
    }

    public void setName(String name){
        this.name=name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age>120||age<0){
            System.out.println("wrong!");
        }
        else {
            this.age = age;
        }
    }
}

class test{
    public static void main(String[] args) {
        encapsulation encapsulation = new encapsulation();
        encapsulation.setName("章茂淳");
        System.out.println(encapsulation.getName());

        encapsulation.setAge(150);
    }
}
//alt+insert 生成get/set方法

继承

1.object类

//entends继承
//Hero是父类,extends_hero是子类/派生类
public class extends_hero extends Yasuo{

}
//ctrl+H 快速显示类的继承图

//在Java中，所有的类，都默认直接或者间接继承Object

extends_hero这个类继承了Yasuo

下面是调用示例，自然地子类可以调用父类public的方法，但是private是无法被继承的，可通过get/set获取/修改

public class Object_Test {
    public static void main(String[] args) {
        extends_hero gamer1 = new extends_hero();
        gamer1.attack();
        System.out.println(gamer1.Bigname);

    }
}

Java中类只有单继承，没有多继承。

一个儿子只用一个爸爸，一个爸爸可以有多个儿子

2.super

super注意点：

1.super调用父类的构造方法，必须在构造方法的第一个，因为先调用父类的构造，再调用子类的方法

2.super必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法

supper和this：

1.代表的对象不同

this：本身调用者的这个对象

super：代表父类对象的引用

2.使用前提

this：在本类中使用

supper：只能在有继承条件下才可以使用

3.构造方法

this();本类的构造

super();父类的构造

3.方法重写

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

public class A extends B{
    public  void test(){
        System.out.println("A的test");
    }
}

public class Object_Test {
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//A

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

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

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大不能缩小 public>protected>default>private

4.抛出的异常：范围可以被缩小，但不能扩大

public class B {
    public void test(){
        System.out.println("B的test");
    }
}

public class A extends B{
    //Override 重写
    @Override
    public void test() {
        System.out.println("A的test");
    }
}

public class Object_Test {
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//A

        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//结果也是A
    }
}

静态方法和非静态方法差别很大！重写和静态方法没有关系（静态方法和一同加载），重写只和非静态方法有关

为什么需要重写？

父类的功能，子类不满足 Alt+Insert+override

多态

1.多态是方法的多态，属性没有多态

2.有父类和子类之间的关系，才能进行类型转换

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

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

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

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

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

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

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s2.run();//student 子类重写了父类的方法，执行了子类的方法
        s1.run();//student

        ((Student)s2).eat();//父类中是没有eat方法的，强制转换,高转低
        s1.eat();
    }
}

instanceof

instanceof是Java中的二元运算符，左边是对象，右边是类；当对象是右边类或子类所创建对象时，返回true；否则，返回false。

public class Object_Test {
    public static void main(String[] args) {
        Object object = new Student();

        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        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(student instanceof String);//编译报错

        //System.out.println(X instanceof Y);
        // X 和 Y 存在父子关系，则能够编译通过
        // X指向的类型(即new出来右边的那个)和 Y 有父子关系，则instanceof的结果是true，反之则为false
    }
}

类型强制转换

1.父类引用指向子类的对象

2.把子类转换为父类，向上转型，自动转换，可能丢失自己本来的一些方法

3.把父类转换为子类，向下转型，强制转换

4.方便方法的调用，减少重复的代码

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

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

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

        //高（父）               低（子）
        Person student = new Student();
        //student.go(),Person里面没有go方法，将student这个对象强制转换成Student类型，我们就可以使用Student类型的方法了。
        ((Student)student).go();
    }
}

static关键字详解

public class Student {
    private static int age;
    private double score;

    public void run(){

    }

    public static void go(){

    }

    public static void main(String[] args) {
        Student s1 = new Student();

        //
        System.out.println(Student.age);//静态变量可以通过类名直接调用
        //System.out.println(Student.score);//非静态的变量不可以用类名调用

        System.out.println(s1.score);//实例化一个对象 s1 则都可以访问
        System.out.println(s1.age);
        
        //也可用类名直接调用静态方法
        Student.go();
        //Student.run;
        go();
        //run();
    }
}

执行顺序

public class Teacher {
    //匿名代码块可赋初值
    {
        System.out.println("匿名代码块");
    }
    //静态代码块只执行一次
    static{
        System.out.println("静态代码块");
    }
    public Teacher(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        new Teacher();
        System.out.println("==============");
        new Teacher();
    }
}

//ouput：
//静态代码块
//匿名代码块
//构造方法
//==============
//匿名代码块
//构造方法

static静态导入包

//还可用于静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class Object_Test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}

被final修饰的类无法被继承！！！

抽象类abstract

1.不能new这个abstract的抽象类，只能靠子类去实现它

2.抽象类中可以写普通的方法

3.抽象的方法必须在抽象类中

//abstract 抽象类  Java类都是单继承的  (接口可以多继承！)
public abstract class action {
    //abstract,抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();
}

public class action_son extends action{
    @Override
    public void doSomething() {

    }
}

接口

声明类的关键字是class，声明接口的关键字是interface

public interface UserService {
    //常量都是public static final
    int age=99;

    //接口中的所有定义其实都是抽象的 public abstract

    void run(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

public interface TimeServer {
    void timer();
}

//类通过 implements 实现接口
//实现了接口的类，就需要重写接口中的方法

//多继承-利用接口实现多继承
public class UserServiceImpl implements UserService,TimeServer{
    @Override
    public void run(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

接口不能被实例化，接口中没有构造方法

内部类

class嵌套

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

    class Inner{
        public void in(){
            System.out.println("内部类方法");
        }

        public void getID(){
            System.out.println(id);
        }
    }
}

public class Object_Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
        //通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();
    }
}

局部内部类

public class Outer {
    public void method(){
        class Inner{
            public void in(){
                
            }
        }
    }
}

异常机制

Error通常是灾难性的致命性错误

Exception通常是可以被程序处理的

异常处理机制

抛出异常

捕获异常

异常处理五个关键字：

try、catch、finally、throw、throws

public class expect {
    public static void main(String[] args) {
        int a=1;
        int b=0;

        try{  //监控区域
            System.out.println(a/b);
        } catch (Exception e) { //捕获异常,catch里的参数为“想要捕获的异常类型”
            System.out.println("Exception");
        }catch (Error e){
            System.out.println("Error");
        }catch(Throwable throwable){
            System.out.println("Throwable");
        }
        finally { //处理善后工作,但是finally不是必须的
            System.out.println("finally");
        }
    }
}

Ctrl+Alt+T //快捷键，添加try/catch或者其它逻辑语句
在这里插入图片描述

throw/throws的用法

public class expect {
    public static void main(String[] args) {
        try {
            new expect().test(0);
        } catch (ArithmeticException e) {
            e.printStackTrace();
        }

    }

    //假设这个方法中，处理不了这个异常，方法上抛出异常
    public void test(int a)throws ArithmeticException{
        if (a==0) {
            throw new ArithmeticException();//1.主动抛出异常，一般在方法中使用
        }
    }
}

自定义异常

使用自定义异常类的步骤：

1.创建自定义异常类，继承一个异常类

2.在在方法中通过throw关键字抛出异常

3.如果在当前抛出异常的方法中处理异常，可以用try-catch语句捕获处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作

4.在出现异常方法的调用者中捕获并处理异常

//自定义的异常类
public class MyException extends Exception{

    //传递数字>10
    private int detail;

    public MyException(int a){
        this.detail=a;
    }

    @Override
    public String toString() {
        return "MyException{" +
                "detail=" + detail +
                '}';
    }
}

public class Exception_Test {

    //可能会存在异常的方法
    static void test(int a) throws MyException {

        System.out.println("传递的参数为："+a);

        if(a>10){
            throw new MyException(a);
        }
        System.out.println("OK");
    }

    public static void main(String[] args) {
        try {
            test(11);
        } catch (MyException e) {
            System.out.println("MyException"+e);
        }
    }
}

注意：

1.在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常

2.在catch中增加一些处理异常的代码

3.尽量添加finally语句块去释放占用的资源

weixin_51454889

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
JAVA面向对象编程的思想

面向对象编程什么是面向对象？以类的方式组织代码，以对象的形式组织（封装）数据。三大特性封装继承多态方法调用1.静态方法可直接调用（和类一起加载）2.非静态方法需要实例化这个类（类实例化之后才存在）3.引用传递传递的是一个对象(可见 Hero.java)public class Person_test {public static void main(String[] args) {Person new_person = new Person();System.out.pr
复制链接

扫一扫

专栏目录