Java基础Day06（面向对象编程oop*）

最新推荐文章于 2024-09-05 11:00:53 发布

qq_53083806

最新推荐文章于 2024-09-05 11:00:53 发布

阅读量238

点赞数

分类专栏：自学文章标签： java

本文链接：https://blog.csdn.net/qq_53083806/article/details/123872991

版权

自学专栏收录该内容

10 篇文章 0 订阅

订阅专栏

本文介绍了面向对象编程的基本概念，如封装、继承和多态，以及构造器的使用，包括无参和有参构造。重点讲解了类与对象的关系、方法定义、属性和对象创建，以及封装、继承在解决复杂问题中的应用。同时涵盖了异常机制和多态性在实际编程中的运用。

摘要由CSDN通过智能技术生成

1.初识面向对象

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题
对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到围观操作，仍需要面向过程的思路去处理
面向对象编程的本质：以类的方式组织代码，以对象的组织（封装数据）。
抽象
三大特性
封装
继承
多态

2.构造器

构造方法的特点
1.必须和类名相同
2.必须没有返回值类型，也不能写void
作用
1.new 本质是调用构造方法
2.初始化对象的值
注意点
1.定义有参构造之后，如果想使用无参构造，自己再定义一个无参构造

package com.oop.demo;

public class Person {
    String name;
    //使用new关键字，本质是在调用构造器
    //无参构造
    public Person(){

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

package com.oop.demo;

public class Person {
    String name;
    //使用new关键字，本质是在调用构造器
    //用来初始化值
    public Person(){

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

快捷键： alt+insert 点击Constructor
什么都不写的时候会存在一个默认构造器

3.小结

1.类与对象
类是一个模板；抽象，对象是一个具体的实例
2.方法
定义，调用！
3.对象的引用
引用类型：基本类型（8）
对象是通过引用来操作的：栈—>堆
4.属性：字段field 成员变量
默认初始化
数字0 0.0
char：u0000
boolean：false
引用：null
修饰符属性类型属性名 = 属性值
5.对象的创建和使用
必须使用new 关键字创造对象，构造器Person fq = new Person();
对象的属性：fq.name
对象的方法：fq.sleep();
6.类：
静态的属性属性
动态的行为方法

4.封装

追求：高内聚低耦合（高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用）。
使用private来设置属性
然后用get、set方法来取值（也可以在方法中设置过滤信息）

5.继承

继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖组合，聚合等
继承关系的两个类。一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
子类和父类之间，从意义上讲应该具有“is a”的关系
快捷键 Ctrl+H 出现树结构

package com.oop.demo;

public class Person {
    protected String name="老大";

}

package com.oop.demo;

public class Student extends Person{
    private String name = "老二";
    public void test(String name){
        System.out.println(name);//输出实例化的
        System.out.println(this.name);//输出自己的
        System.out.println(super.name);//输出父类的
    }
}

package com.oop.demo;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        Student st = new Student();
        st.test("老六");
    }
}

//隐藏代码调用了父类的无参构造
调用父类的构造器必须在子类的第一行

super注意点
	1.super调用父类的构造方法，必须在构造方法的第一个
	2.super必须只能出现在子类的方法或者构造方法中
	3.super和this不能同时调用构造方法
	
VS this
	代表的对象不同
		this：本身调用者这个对象
   		super：代表父类对象的应用
	前提
		this：没有继承也可以使用
		super：只有在继承条件下才可以使用
	构造方法
		this();本类的构造
		super();父类的构造

重写：需要有继承关系，子类重写父类的方法！
	1.方法名必须相同
	2.参数列表必须相同
	3.修饰符：范围可以扩大但不能缩小
	4.抛出的异常：范围，可以被缩小 但不能被扩大
重写：子类的方法和父类的方法必须一致，方法体不同
为什么要重写：
1.父类的功能，子类不一定需要，或者不一定满足

6.多态

动态编译：类型：可扩展性
多态即同一方法可以根据发送对象的不同而采用多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用类型有很多（父类，有关系的类）
多态存在的条件
有继承条件
子类重写父类方法
父类引用指向子类对象
注意：多态是方法的多态，属性没有多态

多态注意事项
1.多态是方法的多态 属性没有多态
2.父类和子类，有联系 类型转换异常！ ClasscastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new Son();
	1.static方法，属于类，它不属于实例；
	2.final 常量；
	3.private方法；

package com.oop.demo;
//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        Student st = new Student();
        st.test("老六");
    }
}

package com.oop.demo01;

import com.oop.demo.Person;

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

package com.oop.demo01;

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

instanceof

System.out.println(x instanceof y);
//判断x和y是否存在父子关系
//如果x是y的父类则输出true

小结

1.父类引用指向子类的对象
2.把子类转换为父类 向上转型（可能会丢失一些自己本来的方法）
3.把父类转换为子类 向下转型，强制转换
4.方便方法的调用，减少重复的代码

static
可全局调用
static{ 静态代码块 }
static静态代码块只执行一次
可以静态导入包
import static java.lang.Math.random;
然后可以在下面直接使用sout(random());
子类不能继承final修饰的父类

7.抽象类abstract

继承类父类的所有方法必须有子类来实现（如果子类也是abstract修饰就不用了）

package com.oop.demo02;
//抽象类 单继承 extends （接口可以多继承）
public abstract class Action {
   //约束，有人帮我们实现
   //abstract,抽象方法，只有方法的名字 没有方法的实现
   public abstract void aa();

   //1.不能new这个抽象类，只能靠子类去实现它
   //2.抽象类中可以写普通方法
   //3.抽象方法必须写在抽象类中
   //抽象的抽象 约束~
}

package com.oop.demo02;
//抽象类
public class A extends Action{

   @Override
   public void aa() {

   }
}

8.接口interface

接口的本质是契约
声名类的关键字是class，声明接口的关键字是interface

package com.oop.demo03;
//interface定义的关键字 接口都需要有实现类
public interface Userservice {
   //接口的所有定义都是抽象的public abstract
   void add();
   void delete();
   void update();
   void query();
}

package com.oop.demo03;
//抽象类：extends
//类 可以实现接口 implements接口
//实现了接口的类，就需要重写接口中的方法
//多继承，可以实现多个接口
public class UserserviceImpl implements Userservice{
   @Override
   public void add() {

   }

   @Override
   public void delete() {

   }

   @Override
   public void update() {

   }

   @Override
   public void query() {

   }
}

接口的作用
1.约束
2.定义一些方法，让不同的人来实现
3.public abstract（定义方法）
4.public static final（定义常量）
5.接口不能被实例化，接口没有构造方法（因为接口不是类）
6.implements可以实现多个接口
7.必须要重写接口中的方法

9.内部类

全员内部类

package com.oop.demo04;

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);
        }
    }

}

package com.oop;

import com.oop.demo01.Pserson;
import com.oop.demo01.Student;
import com.oop.demo04.Outer;

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

匿名内部类

package com.oop.demo04;

public class Test {
   public static void main(String[] args) {
       //没有名字初始化类，不用讲实例保存到变量中
       new Apple().eat();
   }
}
class Apple{
   public void eat(){
       System.out.println("apple");
   }
}

10.异常机制（Exception）

检查性异常
运行时异常
错误Error
异常体系结构
1.Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类
2.在Java API中已经定义了许多异常类，这些异常类分为两大类，错误Error和Exception。
异常处理机制
抛出异常
捕获异常
异常处理的五个关键字：try,catch,finally,throw,throws
//ctrl alt +T 快捷键异常
try catch

package com.exception.demo01;

public class Test {
    public static void main(String[] args) {
        int a = 1;
        int b = 0;
        //假设要捕获多个异常 要从小到大写
        try{//try监控区域
            System.out.println(a/b);
        }catch (ArithmeticException e){//catch捕获异常
            System.out.println("程序出现异常，变量b不能为0");
        }finally {//c处理善后工作（关闭资源）
            System.out.println("finally");
        }
    }
}

throw主动抛出异常

package com.exception.demo01;

public class Test2 {
    public static void main(String[] args) {
        new Test2().test(1,0);
    }
    public static void test(int a,int b){
        if(b==0){
            throw new ArithmeticException();//主动抛出异常，一般在方法中使用
        }
    }
}

throws向上抛出异常

package com.exception.demo01;

public class Test2 {
   public static void main(String[] args) {
       try {
           new Test2().test(1,0);
       } catch (ArithmeticException e) {
           e.printStackTrace();
       } finally {
       }
   }                       //假设这个方法中处理不了这个异常，方法就向上抛出异常
   public static void test(int a,int b) throws ArithmeticException{
       if(b==0){
           throw new ArithmeticException();//主动抛出异常，一般在方法中使用
       }
   }
}

自定义异常
先自定义一个异常继承Exception

package com.exception.demo02;
//自定义异常
public class MyException extends Exception{
    //传递数字>10;
    private int datil;

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

    //toString 异常的打印信息
    @Override
    public String toString() {
        return "MyException{" +
                "datil=" + datil +
                '}';
    }
}

package com.exception.demo02;

public class 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);
        }
    }
}

qq_53083806

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java基础Day06（面向对象编程oop*）

1.初识面向对象物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考，最后才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题，适合处理需要多人协作的问题对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到围观操作，仍需要面向过程的思路去处理面向对象编程的本质：以类的方式组织代码，以对象的组织（封装数据）。抽象三大特性封装继承多态2.构造器构造方法的特点1.必须和类名相
复制链接

扫一扫