java中的类和对象

于 2022-01-19 21:31:55 发布
阅读量571 收藏
点赞数
分类专栏： java开发 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46617079/article/details/122590279
版权
一、面对对象编程

c语言面对过程，python、java面对对象

image-20220116163123169

image-20220116164231287

二、类和对象
1、定义

类和对象：对象是类的实例，包含行为（函数、方法）和状态（键帽、键值）

​ 类是一个设计的框架，是一个模板

2、创建、初始化

创建类：使用class表示创建类

public class Dog {
    //定义类中变量
    String breed;
    int size;
    String colour;
    int age;
    //构造器
    public Dog() {
        this.breed = "a";
        this.size = 10;
        this.colour = "a";
        this.age = 5;
    }
    //定义函数
    void eat() {
    }
 
    void run() {
    }
 
    void sleep(){
    }
 
    void name(){
    }
}
3、构造器

构造器类似python中构造类时的def_main_()函数，初始化类中声明的变量

python

class Ab():
    #这里的def __init__()函数就是python类中的构造器，初始化变量
    def __init__(self, a, b, c):
        #这是要从外界接收的值，赋值就是调用类创建对象的时候：Ab = Ab(1,1,1)
        #若设置默认值，def __init__(self, a = 1, b = 1, c = 1)
        self.a = a
        self.b = b
        self.c = c
        #python不用定义变量类型，不从外界接收的数据，可以直接赋值
        self.e = 1

java java构造器名称和类相同，一个类可以同时构造无参构造器和有参构造器，方便使用

默认存在无参构造，写有参构造，就没无参构造，要再构造

package class_face;

public class Dog {
    String name;
    int age;
    String color;
    //这是java类中的构造器，初始化变量，当创建对象时，可以修改变量值，不修改则为默认变量值
    //若为无参调用，可以不写
    public Dog() {
        this.name = "汪汪";
        this.age = 2;
        this.color = "yellow";
    }
}//创建对象：Dog dog = new Dog(),可以不写构造器

class Bird {
    String name;
    int age;
    String color;
    public Bird(String name) {
        this.name = name;
        this.age  = 10;
        this.color = "black";
    }
}//创建对象，Bird bird = new Bird("bird"),要写构造器
4、类的调用

1、在一个package中，不同java文件中的类， public类和基础类 可以相互调用

2、在不同package中，一个java文件只能调用另一个package中的java文件里面的public类，同时要在开头加上import引用具体的类，也就是java文件名（一个java文件中只能有一个public类，而且与java文件名一致）

三、封装、继承、多态
1、封装

image-20220118120748730

package class_face;

public class a {
    public static void main(String[] args) {
        a1 a1 = new a1();
//        a1.name，此时无法使用
        //使用定义的getName方法获取私有变量
        String name = a1.getName();
        System.out.println(name);
        String name1 = "all Student";
        //使用定义的setName方法修改私有变量；
        a1.setName(name1);
        System.out.println(name1);
    }
}
class a1 {
    //private将变量定义私有变量，创建对象，对象无法使用
    private String name;
    private int age;
    private char id;
    //可以在类中定义一些函数使用这些私有变量
    //获得私有变量的值
    public String getName() {
        return this.name;
    }
    //给私有变量赋值
    public void setName(String name) {
        this.name = name;
    }
}

//在idea中可以使用ALT + Insert设置get/set函数
 concle
     null
     all Student
2、继承

image-20220118124903805

package class_face;

public class b {
    int a;
    int b;
    char c;
    public b() {
        this.a = 1;
        this.b = 2;
        this.c = 'A';
    }
    void d() {
        System.out.println(a);
    }

    public static void main(String[] args) {
        BC bc = new BC();
        //调用类中数据时，先看类中是否存在，类中存在直接使用，类中不存在，看父类是否存在
        System.out.println(bc.c);
        bc.e();
    }
}
//类的继承使用extends， class 子类 extends 父类 ，子类只能有一个父类
//java中所有类默认继承object类
//CTRL + H查看java文件中的类继承

//继承时，不能继承父类的私有变量
class BC extends b {
    int c = 1;
    void e() {
        //子类在自己类中调用数据，加this、super进行区分
        System.out.println(this.c);
        //super直接在子类中调用父类的数据
        System.out.println(super.c);
    }
}
concle
    1
    1
    A

package class_face;

public class e {
    int a;
    char b;
    public e() {
        System.out.println("Keqiang");
    }

    public static void main(String[] args) {
        AB abc = new AB();
    }
}
class AB extends e {
    public AB() {
        //隐藏代码super();   父类构造器   当显示书写时，放在子类构造器的开头
        //自己的有参构造器this();   有参构造器   当书写时，放在子类无参构造器开头
        //super();   this();   不能同时书写
        //super  只能出现在子类的函数和构造其中
        System.out.println("dong");
    }
}
concle
    Keqiang
    dong
3、方法重写

子类重写父类的方法

1、方法名必须相同

2、参数相同

3、修饰符范围可以扩大不能缩小：public > Protected > Default > private

4、抛出的异常范围可以缩小不能扩大

1、父类可以创建子类对象， 父类 对象id = new 子类() 多态

2、静态方法 static 只看对象创建的左边是什么， A a = new A()

3、非静态方法才有重写

4、非静态方法，对象创建看右边是什么， A a = new A()

package class_face;

public class abc {
    public void a() {
        System.out.println("a.abc");
    }
    public void b() {
        System.out.println("b.abc");
    }
    //静态方法，创建子类时，不能使用重写
    public static void c() {
        System.out.println("c.abc");
    }
    public static void main(String[] args) {
        Dong dong1 = new Dong();
        abc abc1 = new abc();
        //多态
        abc dong2 = new Dong();

        dong1.a();
        abc1.a();
        dong2.a();

        System.out.println();
        dong1.b();
        abc1.b();
        dong2.b();

        System.out.println();
        dong1.c();
        abc1.c();
        dong2.c();
    }
}
class Dong extends abc {
    public void a() {
        System.out.println("a.Dong");
    }
    //使用ALT+INS 创建重写
    @Override
    public void b() {
//        super.b();
        System.out.println("b.DongS");
    }
    //静态方法，只看创建对象的左侧
    public static void c() {
        System.out.println("c.Dong");
    }
}
concle
    a.dong
    a.abc
    a.dong
    
    b.dong1
    b.abc1
    b.dong2
    
    c.dong
    c.abc
    c.abc
4、多态

image-20220118223755720

1、多态借助instanceof将一个对象分别转换为不同的类的引用，在不同类中定义相同id和参数的方法，这样就可以调用对象的一个方法出现不同执行

2、在创建对象时，类 id_1 对象id = new 类id_2 对象能执行什么方法主要看类id_1有什么方法

3、只有父类、子类之间才能用

package class_face;

public class application1 {
    public static void main(String[] args) {
        //ab1是父类，ab2是子类
        //父类可以调用自己的方法
        ab1 a1 = new ab1();
        //子类可以调用自己的方法和继承父类的方法
        ab2 a2 = new ab2();
        //父类可以指向子类，同类型的方法调用子类（方法重写），但是不能调用子类独有的方法
        //这种写法，我的理解是，就是方便父类调用子类重写的方法
        ab1 a3 = new ab2();
//        System.out.println("当子类重写方法，即使定义左侧是父类，执行子类重写的方法");
//
//        a1.a1();
//        a2.a1();
//        a3.a1();

        System.out.println("对象方法主要看对象定义 左侧类 的方法");
        a1.a2();
        a2.a2();
        System.out.println("当子类重写方法，即使定义左侧是父类，执行子类重写的方法");

        a1.a1();
        a2.a1();
        a3.a1();

        System.out.println("父类指向子类无法直接调用子类独有的方法");
        //a3.a3()   不能这么书写，不能调用子类独有方法
        //使用强制类型转换，将父类对象指向子类
        ((ab2)a3).a3();
        
        //((ab2)a1).a3();   必须是父类定义子类对象才能使用转换 ： 父类 对象 = new 子类
    }
}
class ab1 {
    public void a1() {
        System.out.println("a1.ab1");
    }
    public void a2() {
        System.out.println("a2.ab1");
    }
    //public void a3() {
    //    System.out.println("a3.ab1");
    //}
}

class ab2 extends ab1 {
//    @Override
    public void a1() {
        System.out.println("a1.ab2");
    }
    public void a2() {
        System.out.println("a2.ab2");
    }
    public void a3() {
        System.out.println("a3.ab2");
    }
}
class ab3 {
    public void a1() {
        System.out.println("a1.ab3");
    }
}
concle
    a2.ab1
    a2.ab2
    
    a1.ab1
    a1.ab2
    a1.ab2
    
    a3.ab2

instanceof 用来判断对象是否和类有关联，输出true false

package class_face;

public class application1 {
    public static void main(String[] args) {
        Person person = new Person();
        Student student = new Student();
        Teacher teacher = new Teacher();
        Person person1 = new Student();
        Student student1 = new Student();
        System.out.println(student instanceof Person);
        System.out.println(teacher instanceof Person);
        System.out.println(teacher instanceof Object);
        System.out.println(person instanceof Student);
        System.out.println();
        System.out.println(person1 instanceof Student);
        System.out.println(person1 instanceof Person);
        System.out.println(person1 instanceof Teacher);
        System.out.println(person1 instanceof Object);
        //不相关的比较直接报错
//        System.out.println(person1 instanceof String);

    }
}
class Person {
    String name;
    int age;
    public void sys() {
        System.out.println("你好");
    }
}

class Student extends Person {

}

class Teacher extends Person {

}
concle
    true
    true
    true
    false
    
    true
    true
    false
    true
四、抽象类、接口
1、抽象类

image-20220119191112406

1、抽象类是一种特殊的类

2、抽象类中可以存在普通方法和抽象方法

3、抽象方法只写方法名和参数，不写具体内容，相当于int定义a，但是不给a赋值

4、子类继承抽象类时，必须重写抽象类中的抽象方法，变为普通方法

5、抽象类不能直接用new创建对象，只能子类创建

package class_face.exe;

public class a {
    public static void main(String[] args) {
        //b b = new b();
        //抽象类不能直接new创建对象
        c c = new c();
    }
}
//abstract 抽象类，可以定义抽象方法
abstract class b {
    //抽象方法
    public abstract void a1();
    //普通方法
    public void a2() {
        
    }
}
//抽象类子类必须重写父类抽象类的抽象方法
class c extends b {
    @Override
    public void a1() {
        
    }
}
2、接口

image-20220119193333948

1、接口创建使用interface，不是class

2、接口可以理解为只能是抽象方法的类

3、在接口文件中定义所有的方法，在类中重写这些方法

4、接口里面的方法可以直接· 类型 方法名(); ，默认为 public abstract

5、接口中基本不定义数据，默认为 public static final

6、类文件调用接口，class 类名 implement 接口1，接口2 { }

7、一个类可以调用多个接口，重写接口中的方法

接口1

package class_face.exe;

public interface a1 {
    void run();
    void sys(String age);
}

接口2

package class_face.exe;

public interface a2 {
    void a();
}

调用接口类

package class_face.exe;

public class a1Imp implements a1,a2{
    @Override
    public void run() {

    }

    @Override
    public void sys(String age) {

    }

    @Override
    public void a() {

    }
}

内部类

image-20220119200755474

五、异常
1、什么叫做异常

image-20220119203648838

2、异常分类

image-20220119204210209

image-20220119204343232

image-20220119204417164

image-20220119205136970

3、异常处理机制

image-20220119204649209

package exception;

public class a {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try{
            //try内部异常监察部分代码
            System.out.println(a/b);
        }catch(Exception e){
            //catch()中写捕捉异常类型
            //捕捉到异常，执行catch中的内容
            System.out.println("b=0");
        }finally {
            //finally中的内容执行，一般异常结束处理
            System.out.println("异常");
        }
    }
}

package exception;

public class b {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        a2(a,b);
        a1(a,b);
    }
    //当方法内无法处理异常，在方法上throws
    public static void a1(int a, int b) throws RuntimeException{
        if (b == 0) {

        }
        System.out.println("a");
    }
    public static void a2(int a, int b) {
        if (b == 0){
            //方法内throw异常
            throw new RuntimeException();
        }
        System.out.println("b");
    }
}

自定义异常

image-20220119212757614

设置类，继承Exception类

弗洛伊德和迪杰斯特拉
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值