• 类和对象


    一、 定义

    对象:具有一组属性和方法的实体。万事万物皆对象。

    类:具有相同属性和方法的对象的集合。抽象的概念。

    关系:类是对象的抽象,对象是类的具体存在。

    二、 类

    1. 定义类

    访问修饰符   class   类名{

    //定义属性

    //定义方法

    }

    public  class  Student{

    String name;

    int age;

    public  void  study(){

    }

    public  void  eat(String food){

    }

    }

    1. 创建对象

    语法:类名  对象名  =  new  类名();

    示例:Student  stu  =  new  Student();

    通过对象名+.的方式可以调用类的成员(属性、方法)。

    stu.name = “zhangsan”;   

    stu.study();

    1. JAVA中的数据类型

    u 基本数据类型(值类型)

    1) 整型:byteshortintlong

    2) 浮点型:floatdouble

    3) 字符型:char

    4) 布尔型:boolean

    u 引用数据类型:

    1) String

    2) 数组

    3) 类

    三、 方法

    1. 定义方法

    语法:访问修饰符   返回值类型   方法名称(数据类型  参数名,  数据类型  参数名){

              //方法体

    }

    注意:

    如果方法没有任何返回值,那么返回值类型写void

    如果方法有返回值,那么应该使用return关键字将结果值返回。

    u 方法的参数列表可以为空。

    u 定义方法时,参数列表中的参数为形参(形式参数)。

    u 方法体中不能再定义其他方法。

    1. 方法的调用

    语法:通过对象名.方法名进行方法的调用。

    注意:

    u 方法如果有参数,那么必须传递参数(参数的类型、个数)。

    u 参数如果为值类型,方法调用前后,实参的值不变;参数如果为引用类型,方法调用前后,实参的值要改变。

    u 如果方法定义时,没有返回值,那么不能定义变量接受方法的返回值。

    u 如果方法定义时,有返回值,那么可以定义变量接收返回值;也可以不定义变量接受。

    u 同一类中相互调用方法时,直接通过方法名调用。

    public  class  Teacher{

    public  void  teach(){

        study();

    }

    public void study(){

    }

    }

    不同类中调用方法时,需要首先创建类对象,通过对象名.方法名()进行调用。

    public  class  Teacher{

    public void teach(){

    }

    }

    public  class  Student(){

    public  void  learn(){

        //调用Teacher类中的teach方法

        Teacher  teacher = new  Teacher();

        teacher.teach();

    }

    }

    方法调用时,不需要写{}

    Teacher  teacher  =  new  Teacher();

    teacher.teach(){};//错误

    teacher.teach();//正确

    1. 构造方法

    u 构造方法的方法名和类名相同。

    u 如果没有显示定义构造方法,那么系统会默认创建一个无参的构造方法。

    u 如果显示定义了构造方法,那么系统将不会再创建任何构造方法。

    u 构造方法没有返回值类型。

    u 一个类中可以存在多个构造方法。

    创建类对象时,关键字new后面跟的就是类的构造方法。

    1. 方法的重载
      1. 重载需要满足以下条件:

    在同一个类中

    方法名相同

    参数列表不同(参数个数不同、参数类型不同、参数顺序不同)

    1. 注意:方法的访问修饰符和返回值类型不在考虑范围之内。

    四、 局部变量和成员变量

    成员变量:类中定义的属性或字段就是成变量。

    局部变量:方法中定义的变量、代码块中定义的变量({})都是局部变量。

    成员变量可以通过this进行访问;局部变量不可以。

    成员变量的优先级 < 局部变量的优先级

    成员变量,在类的所有方法中均可以使用;但是局部变量只能在相应的代码块中使用。

    五、 类成员的访问修饰符

                           同一个类中             同一个包中           子类中          任何地方           

        private              yes                     no                  no              no

        默认修饰符            yes                     yes                 no              no

        protected            yes                     yes                 yes             no

    public               yes                     yes                 yes             yes

        注意:优先级从低到高依次为:private(私有) < 默认 < protected(受保护) < public(公共)

        上述访问修饰符适用于:属性、方法。不适用于类,类的访问修饰符只有2个:public和默认修饰符。

    六、 JAVA中的命名规则

    1. 驼峰命名法

    标识符中,第一个英文单词首字母小写,其他单词首字母均大写。

    1. 帕斯卡命名法

    标识符中,所有英文单词首字母均大写。

    1. JAVA中的命名规则

    包:全小写。

    类:帕斯卡命名法。

    属性|方法:驼峰命名法。

    七、 静态成员

    1. 定义

    static关键字修饰的成员就是静态成员,静态成员包括:静态属性、静态方法、静态代码块。

    public  class  MathHelper{

    //定义静态成员

    public static final double PI = 3.14;

    //静态代码块

    static{

        //代码

    }

    //静态方法

    public  static  double  calculateCircleArea(double  r){

        return PI * r * r;

    }

    }

    1. 注意事项

    静态成员需要通过类名进行调用:double area = MathHelper.calculateCircleArea(5.0)

    u 静态代码块只执行一次,并且在系统启动时执行。

    u 静态成员虽然使用方便(不需要事先实例化),但是静态成员在内存中会一直存在。

    八、 包

    1. 设置类所在的包:在源文件的第一行添加:  package 包名

          package com.bdqnsjz.demo;

          public class Test{}

    1. 导入包:在源文件的package和类名中间添加:  import 包名

          package com.bdqnsjz.demo;

          import com.dbqnsjz.homework;

          public class Test{}

    1. 注意:

    u 包名由小写字母组成,不能以圆点开头或结尾

    u 包名之前最好加上唯一的前缀,通常使用组织倒置的网络域名

    u 常见的包:

    java.lang:虚拟机自动引入

    java.util:提供一些实用类

    java.io:   输入、输出

    u packageimport的顺序是固定的:

    1.package必须位于第一行(忽略注释行)

    2.只允许有一个package语句

    3.其次是import

    4.接着是类的声明

    九、 封装

    1. 定义

    将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。

    public  class  Student{

    private  String  name;

    private  int  age;

    public  String  getName(){

        return this.name;

    }

    public  void  setName(String  name){

        this.name  =  name;

    }

    }

    1. 通俗的讲,封装就是将类的属性(字段)设置为私有的(private),并添加getter/setter方法操作属性。

    十、 继承

    1. 目的

    解决代码冗余的问题。

    1. 语法:

              public class 子类名 extends 父类名{

              }

    1. 注意:

    1.子类(扩展类)、父类(基类)

          2.一个类只有有1个父类

          3.在父类中被protected修饰符修饰的变量,可以在子类中访问。

            在父类中被private修饰符修饰的变量,不可以在子类中访问。

          4.在子类中通过super关键字来访问父类的成员。

            在当前类中通过this关键字来访问本类的成员。

          5.实例化子类对象时,会默认调用父类无参的构造方法。

          6.在子类中调用父类构造方法时,应该在子类的构造方法的第一行进行调用。

    1. 方法的重写

    定义:子类重新实现父类的方法。

    要求:方法名相同;参数列表相同;返回值类型相同;子类方法访问修饰符高于父类方法的修饰符。

        注解:@Override  重写

    1. 方法重载和方法重写的区别

        1.方法重写研究的是子类和父类,方法的重载研究的是同一个类中的方法

        2.方法重写的方法名要相同,方法重载时方法名也相同

        3.方法重写时,参数列表相同,方法重载时,参数列表不同。

        4.方法重写时,返回值相同,方法重载时,返回值类型无关。

    1. Object

        1.Object是所有类的父类(所有类都直接或间接继承自Object类)

        2.判断值类型的变量是否相等用==   判断引用类型的变量是否相等用equals

        3.hashCode哈希值。每次通过构造方法创建类的对象后,都有1个唯一的哈希值。

    1. instanceof关键字

        用途:instanceof用于判断一个引用类型所引用的对象是否是一个类的实例。

    向上转型:子类对象转父类对象       

    Pet pet1 = new Dog();      Pet pet2 = new Penguin();

    向下转型:父类对象转子类对象       

    Dog dog = (Dog)pet1;       Penguin penguin = (Penguin)pet1;//null

    注意:向上转型安全,向下转型有风险,可能会存在类型不兼容的问题。

    解决办法就是使用instanceof关键字判断是否类型兼容。

    十一、 多态

    1. 定义:

    同一个引用类型,使用不同的实例而执行不同操作。

    1. 具体实现步骤:

    1.定义父类和子类,在子类中重写父类的方法;

    2.定义一个方法,方法的参数为父类型,在方法中调用父类被重写的方法;

    3.调用该方法时,传递子类对象,结果执行的为子类的方法,而非父类的方法。

    1. 注意:

    多态中涉及到的类应该存在继承关系。

    里氏代换原则(凡是出现父类的地方,都可以使用子类对象)

    public void takeCare(Pet pet){

    pet.cure();

    }

    Pet dog = new Dog();

    Pet penguin = new Penguin();

    doctor.takeCare(dog);

    doctor.takeCare(penguin);

    十二、 抽象类

    抽象方法:被abstract关键字修饰的方法就是抽象方法。

    抽象类:被abstract关键字修饰的类就是抽象类。

    注意:

    1. 抽象方法不能有方法体。    

    public abstract void run();

    1. 抽象方法所在的类一定是抽象类。    

    public abstract class Traffic{}

    1. 抽象类中的方法不一定都是抽象方法。
    2. 抽象类无法直接实例化创建对象,必须调用子类的构造方法创建对象。

    十三、 接口

    1. 定义:

    接口用于提供一种约定(方法),使得实现接口的类在形式上保持一致。

    1. 语法:

    public interface 接口名{

    //抽象方法

    }

    public class 类名 implements 接口名{

            //实现接口中所有的抽象方法

    }

    1. 注意:

    1.接口中只能包含抽象方法(不需要使用abstract关键字修饰)

    2.一个类可以实现多个接口(只能继承1个类)

    3.接口不能直接被实例化(由实现类去实例化接口)

    4.一个接口可以继承多个接口

    5.一个类可以实现多个接口

    6.接口中的所有方法都为抽象方法

    7.抽象类实现接口后,可以不实现接口中的抽象方法

    十四、 异常

    1. 定义

    异常是指在程序运行过程中所发生的不正常的事件,它会中断正在运行的程序。

    1. 异常相关的关键字

        trycatchfinallythrowthrows

    u try:执行可能产生异常的代码

    u catch:捕获异常,编写处理异常的代码

    u finally:无论是否发生异常,都要执行的代码块

    u throw:手动抛出异常

    u throws:声明方法可能要抛出的各种异常

    1. 注意

    u try代码块有可能出现异常也可能不会出现异常

    只有try代码块出现异常时,catch代码块才会执行

    u try中的代码块一旦出现异常,那么出现异常后面的代码不会继续执行。

    u ex.printStackTrace()方法用于向控制台打印输出异常堆栈信息(在执行哪一行代码时出现什么异常)

    如果出现的异常类型和catch块中异常的类型匹配,那么才会执行catch块中的代码,否则不执行。

    所有异常类均直接或间接继承自类Exception

    多重catch  try代码块后,包含了多个catch代码块

    多重catch时,Exception一定要放在最后

    u System.exit(1);表示强制性退出系统。

    u try-catch-finally结构中try语句块是必须的,catchfinally语句块均可选,但两者至少出现之一

    u try-catch块中存在return语句,是否还执行finally块,如果执行,说出执行顺序

    1. 常见的异常

    1.ArrayIndexOutOfBoundsException   数组下标越界异常

    2.NullPointerException              空指针异常

    3.NumberFormatException             数字格式化异常

    4.ArithmeticException               算术运算异常

    5.RuntimeException                  运行时异常

    6.FileNotFoundException            文件未找到异常

    7.IOException                       输入输出异常

    8.NoSuchMethodException            方法未找到异常

    9.Exception                         所有异常的父类

    10.ClassCastException              类型强制转换异常

  • 相关阅读:
    python
    spice-vdagent
    no ia32-libs
    git conflict
    wget mirror
    docker !veth
    libprotobuff8.so not found
    angular 列表渲染机制
    Java测试技巧
    react组件生命周期
  • 原文地址:https://www.cnblogs.com/daniel-wang/p/6431186.html
Copyright © 2020-2023  润新知