JAVA基础笔记——对象、异常、static总结

JAVA基础笔记——对象、异常、static总结

  • 一、对象
    • 1.1 对象的创建
    • 1.2 类中的构造器/构造方法
    • 1.3 对象建立、内存分析
      • 1.3.1 堆
      • 1.3.2 栈
      • 1.3.3 方法区
      • 1.3.4 对象建立过程中内存分配分析
    • 1.4 对象的特性
      • 1.4.1 封装
      • 1.4.2 继承
        • 1.4.2.1 继承的使用
        • 1.4.2.2 Object类
        • 1.4.2.3 this/super
        • 1.4.2.4 方法重写
      • 1.4.3 多态
        • 1.4.3.1 多态的使用
        • 1.4.3.2 instanceof
        • 1.4.3.3 类型转换
    • 1.5 final
      • 1.5.1 修饰类
      • 1.5.2 修饰方法
      • 1.5.3 修饰局部变量
      • 1.5.4 修饰成员变量
    • 1.6 抽象类/方法
    • 1.7 接口
    • 1.8 内部类
      • 1.8.1 成员内部类
      • 1.8.2 静态内部类
      • 1.8.3 局部内部类
      • 1.8.4 匿名内部类
  • 二、static的总结
    • 2.1 类中的static
    • 2.2 静态导入包
  • 三、异常
    • 3.1 异常定义和体系结构
    • 3.2 捕获异常
    • 3.3 抛出异常
    • 3.4 自定义异常


一、对象

打补丁:类的命名应遵守首字母大写和驼峰原则

1.1 对象的创建

tips:

  1. 本质:类是抽象的,对象是类的具体化;以类的方法组织代码,以对象的方式封装数据
  2. 创建:使用new创建对象,除了分配内存空间外,会给建立好的对象进行默认的初始化或者调用类中的构造器
  3. example:新建学生类,显示默认的初始化成员
    1)学生类 stu.java
public class stu {
    //属性
    String name;
    int age;
    //方法
    public void setAge(int stuAge){
        this.age=stuAge;
    }
    public int getAge(){
        return this.age;
    }
}

2)运行代码 application.java

public class application {
    public static void main(String[] args) {
        //new实例化类
        stu stuList=new stu();
        int stuAge=stuList.getAge();
        System.out.println("年龄:"+stuAge);
    }
}

3)测试结果
JAVA基础笔记——对象、异常、static总结_第1张图片

1.2 类中的构造器/构造方法

tips:

  1. 作用:用于对象初始化
  2. 显式和隐式构造方法:
    1) 当没有显式定义任何构造方法时,系统默认一个构造方法,给所有成员赋默认值;
    2)当显式定义有参构造方法后,无参构造方法也必须显式定义,否则无参实例化会报错;
    3)必须写无参构造方法,避免父类只有有参构造方法导致子类的构造方法报错(原因:父类没有可调用的无参构造方法,详见继承)
  3. 特点:
    1)构造方法名与类名一致;
    2)必须没有返回值,特别是不可以写void
  4. idea的构造方法(读写成员变量等)自动生成快捷键
    Alt+Insert,如果insert在键盘中与其他按键共建(如跟F12或者Delete),则快捷键为Fn+Alt+Insert
    1)按下快捷键,选择生成“构造函数”
    JAVA基础笔记——对象、异常、static总结_第2张图片
    2)长按ctrl,通过鼠标单击选择(取消)初始化的字段,ctrl+A全选,此处需要注意,当显式有参构造方法后,无参构造方法也需要显式定义
    JAVA基础笔记——对象、异常、static总结_第3张图片
    3)生成代码:
    在这里插入图片描述
    5.example:新建学生类,使用有参和无参构造方法
    1)学生类 stu.java
public class stu {
    //属性
    String name;
    int age;
    double height;
    //方法
    public stu() {
        System.out.println("无参构造方法被调用");
    }
    public stu(String name, int age,double height) {
        this.name = name;
        this.age = age;
        this.height=height;
        System.out.println("有参构造方法被调用");
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

2)运行代码 application.java

public class application {
    public static void main(String[] args) {
        //new实例化类
        stu stuNull=new stu();
        stu stuList=new stu("liqour",21,180);
        int stuAge=stuList.getAge();
        System.out.println("年龄:"+stuAge);

    }
}

3)测试结果
JAVA基础笔记——对象、异常、static总结_第4张图片

1.3 对象建立、内存分析

1.3.1 堆

tips:

  1. 存放new的对象和数组
  2. 可以被所有的线程共享

1.3.2 栈

tips:

  1. 存放基本变量类型和具体数值
  2. 引用对象的变量和该引用变量在堆里的地址

1.3.3 方法区

tips:

  1. 是堆中一个特殊的区域
  2. 可以被所有的线程共享
  3. 包含了所有的class类和static变量/方法

1.3.4 对象建立过程中内存分配分析

tips:

  1. example:一个学生类,建立两个对象stuA和stuB。
    1)学生类 stu.java
public class stu {
    //属性
    int age;
    String name;
    //方法
    public stu() {
        System.out.println("无参构造方法被调用");
    }
    public stu(int age, String name) {
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

2)运行代码 application.java

public class application {
    public static void main(String[] args) {
        //new实例化类
        stu stuA=new stu(21,"liquor");
        int stuAge= stuA.getAge();
        System.out.println("A年龄:"+stuAge);
        stu stuB=new stu(20,"gin");
        stuAge= stuB.getAge();
        System.out.println("B年龄:"+stuAge);
    }
}

3)内存分配
JAVA基础笔记——对象、异常、static总结_第5张图片

1.4 对象的特性

1.4.1 封装

tips:
1.程序设计需要追求高内聚,低耦合。类的内部数据操作细节自己完成,外部不可干涉;尽量少向外部暴露。
2.方法:属性定义为私有private,通过get/set获取/修改(快捷键Alt+Fn+Insert)

1.4.2 继承

1.4.2.1 继承的使用

tips:

  1. 本质:对一批类的抽象,是类之间的关系,子类(派生类)继承成父类(基类)
  2. 目的:较少重复的代码,提高可维护性
  3. 单继承和多继承:
    JAVA只有单继承,没有多继承(C++)
    单继承:一个子类只能继承一个父类,java
    多继承:一个子类可以继承多个父类,c++
  4. 意义: 子类拥有父类非private的属性和方法(私有private无法被继承);子类在父类的基础上进行拓展(即拥有自己的方法)
  5. 语法结构:在子类申明时使用关键字extends
public class 子类名 extends 父类名
{
	子类内容;
}
  1. 在类的方法中调用本身的属性/方法,使用关键字this
    在类的方法中调用父类的属性/方法,使用关键字super
  2. 父类子类的构造方法
    1)系统默认在子类构造方法的最初隐式调用父类的无参构造方法,若需要在子类构造方法中显式调用父类的有参构造方法,则调用必须写在第一行,调用语句:super(传递给父类构造方法实参表);
    2)父类一定要显式写明无参构造方法,因为子类的构造方法中,若没有显式调用父类有参的构造方法,系统默认在代码最初隐式调用父类的无参构造方法。如果父类只显式声明了有参构造方法,会导致系统默认的父类的无参构造方法失效(详见类的建立),使得子类在隐式调用时报错。
    example:
    1)Person类
public class Person {
	//属性
    private String name;
    private int age;
	//无参
    public Person() {
        System.out.println("Person的无参构造方法被调用");
    }
	//有参
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

2)Stu类

public class Stu extends Person{
    //属性
    private String name;
    //方法
    //无参
    public Stu() {
    //此处存在系统隐式调用的父类无参构造函数
        System.out.println("Stu的无参构造方法被调用");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
	//有参
    public Stu(int age, String name, String stuName) {
        //显式调用父类的有参构造函数
        super(name,age);
        //父类构造函数必须在第一行
        this.name=stuName;
        System.out.print("Person类的姓名:"+super.getName()+"\n");//取父类的非private方法
        System.out.println("Stu类的姓名:"+this.getName());//调用本身
    }
}

3)运行代码 Application.java

public class Application {
    public static void main(String[] args) {
        //子类无参构造
        Stu stuA=new Stu();
        //子类有参构造
        Stu stuB=new Stu(21,"liquor","gin");
    }
}

4)运行结果
JAVA基础笔记——对象、异常、static总结_第6张图片

1.4.2.2 Object类

tips:

  1. 在java中,所有的类都会自动继承Object类
  2. /******后续回来打补丁/

1.4.2.3 this/super

tips:

  1. super用于在类中调用父类的非private方法和属性;
  2. this用于在类中调用自身的方法和属性;
  3. super(实参表);用于调用父类的构造方法,在子类构造的第一行
  4. this(实参表);用于本类的构造,也需要在第一行,所以this()和super()调用构造方法都要求在第一行,不能同时出现在一个方法中

1.4.2.4 方法重写

tips:

  1. 作用意义:由于父类的功能不满足子类的具体需要,子类对父类非私有、非静态的方法,重写内容

  2. 特性:
    1)是继承之间,子类对父类操作
    2)方法名和参数列表必须一致
    3)子类重写的方法修饰符范围只能缩小不能扩大(public>protected>default>private)
    4)重写会抛出异常,子类异常的范围可以缩小不能扩大

  3. IDEA快捷键:Ctrl+O或者在生成栏(Fn+Insert+Alt)中可以自动生成代码

  4. 重写方法中,父类会有标记(箭头向下)
    在这里插入图片描述
    子类会有标记(箭头向上)和注释 @OverrideJAVA基础笔记——对象、异常、static总结_第7张图片

  5. 方法是否静态(staitc)

方法状态 影响
静态 静态方法的调用只和定义的左边的类型有关(非重写)
非静态 当父类的引用指向子类(多态),非静态非私有的,调用子类的方法

1.4.3 多态

1.4.3.1 多态的使用

tips:

  1. 动态编译,类型有可扩展性
  2. 一个对象的实际类型是确定的,但指向的引用类型可以不确定,如父类的变量new子类
  3. 父类的引用指向子类(多态),比如,若F是S的父类
F father=new S();
  1. 父类子类之间调用关系(假设F是父类,S是子类)
声明 调用范围
子类变量new子类,S a=new S(); 对象a能调用自己的方法或者从父类继承的非私有的方法
父变量new子类,F a=new S(); 当子类S中有对父类F非私有非静态方法重写时,调用子类重写的方法;但是不可以调用子类独有的方法
  1. 特性:
    1)多态只有方法,没有属性
    2)多态是父类变量New子类,必须有父子关系,否则出现类型转换异常,报错:ClassCastException!

  2. 动态的父类调用逻辑
    1)首先看该方法能否被调用,即父类是否拥有该方法。某种方法(名)能否被调用,看等式的左侧类型是否包含该方法(即多态的父类变量不可以调用子类独有的方法,此处要与继承区分,继承是子类可以调用父类所有非私有的方法),见example1。
    2)其次看该方法是否被子类重写,若该方法(非私有非静态)被子类重写,则动态的父类调用子类的方法。见example2。

  3. example1:
    父类Person独有非静态非私有方法fatherTest(),可以被子类变量继承调用;子类Stu独有方法不能被父类变量调用
    1)父类Person

public class Person {
    private String name;
    private int age;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void fatherTest(){
        System.out.println("fatherTest");
    }
}

2)子类Stu

public class Stu extends Person{
    //方法
    public Stu() {
    }
    public Stu(int age, String name) {
        //显式调用父类的有参构造函数
        super(name,age);
    }

   public void sonTest()
   {
       System.out.println("SonTest");
   }
}

3)运行代码(报错截图) Application.java
JAVA基础笔记——对象、异常、static总结_第8张图片

  1. example2:
    父类Person,子类Stu,对test()重写,testSta()作为静态方法参照
    1)父类Person
public class Person {
    private String name;
    private int age;

    public Person() {
    }
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void test() {
        System.out.println("Person->getName");
    }

    public static void testSta() {
        System.out.println("Person->test");
    }
}

2)子类Stu

public class Stu extends Person{
    //方法
    public Stu() {
    }
    public Stu(int age, String name) {
        //显式调用父类的有参构造函数
        super(name,age);
    }

    @Override
    public void test() {
        System.out.println("Stu->getName");

    }
    public static void testSta() {
        System.out.println("Stu->test");
    }
}

3)测试代码 Application.java

package oop;

public class Application {
    public static void main(String[] args) {
        Stu stuA=new Stu();
        Person stuB=new Stu();//重写
        Person stuC=new Person();
        //非静态
        stuA.test();
        stuB.test();
        stuC.test();
        //静态
        stuA.testSta();
        stuB.testSta();
        stuC.testSta();

    }
}

4)运行结果
JAVA基础笔记——对象、异常、static总结_第9张图片

1.4.3.2 instanceof

tips:

  1. 作用:判断类之间是否存在父子/祖先子孙关系
  2. 语法结构:A、B、C为类
A relVar=new B();
boolean result=relVar instanceof C;
  1. 原型链:从该类型向上回溯所有的祖先类
    比如,对于example中的配图,Teacher的原型链为Teacher->Person->Object;Person的原型链为Person->Object
  2. 判断方法:
    1)是否通过编译:若C在A的原型链或者是以A为根的树上(以A为源头,向下找树,向上找链),则instanceof可以通过编译
    2)是否为True:以B为起点,向上回溯原型链(即B的所有父类、祖父类和本身)
  3. example:标红经过结点符合要求
    1)判断以下类的关系:
    JAVA基础笔记——对象、异常、static总结_第10张图片
    2)Object ob=new Stu();

可编译:
JAVA基础笔记——对象、异常、static总结_第11张图片

结果为True:

JAVA基础笔记——对象、异常、static总结_第12张图片

运行结果:
JAVA基础笔记——对象、异常、static总结_第13张图片
3)Person per=new Stu();
可编译:
JAVA基础笔记——对象、异常、static总结_第14张图片
结果为True:
JAVA基础笔记——对象、异常、static总结_第15张图片
运行结果:
JAVA基础笔记——对象、异常、static总结_第16张图片
4)Person person=new Person();
可编译:
JAVA基础笔记——对象、异常、static总结_第17张图片
结果为True:

JAVA基础笔记——对象、异常、static总结_第18张图片
测试结果:
JAVA基础笔记——对象、异常、static总结_第19张图片

1.4.3.3 类型转换

tips:
1.方便方法调用,用于解决父类引用指向子类时,又希望调用子类独有方法的情况。

转换方向 方法 应用
父类转换子类 强制转换 解决父类引用指向子类时,解决多态存在父类变量不可以调用子类独有的方法的问题
子类转换父类 自动转换 见多态
  1. 语法结构:F为父类,独有方法fatherTest();S为子类,独有方法sonTest()
F relVar=new S();
((S) relVar).sonTest();

1.5 final

参考整理自Java中final关键字

1.5.1 修饰类

  1. 作用:终止继续向下继承
  2. 语法结构:
public final class 类名{

}
  1. 特性:不能与abstract共用

1.5.2 修饰方法

tips:

  1. 作用:禁止该方法被覆盖重写
  2. 语法结构:
public final 返回值类型 方法名(形参表){

}
  1. 特性:不能与abstract共用

1.5.3 修饰局部变量

tips:

  1. 对于基本变量,变量的数值不可改变
  2. 对于引用变量,变量中存储的地址不可改变(即不可以换另一个对象),但地址指向的对象本身内容可变

1.5.4 修饰成员变量

tips:

  1. 对于成员变量,修饰后变量的值也不可以改变,即不可以再调用set()函数修改
  2. 使用final后需要显式赋值,系统不再赋默认值
  3. 对于final修饰的成员变量显式赋值,可通过直接赋值或者构造方法赋值,其中,构造方法要保证所有重载的方法都对该变量赋值

1.6 抽象类/方法

tips:

  1. 修饰符abstract,可以用于修饰类或者方法
  2. java的抽象类只能单继承,具有局限性
  3. 语法结构:
public abstract class 类名{

	public abstract void test();

}
  1. 抽象类中可以没有抽象方法,但是抽象方法的类一定要声明为抽象类
  2. 抽象类不能通过new来创建具体的对象,本质上是用于子类继承的
  3. 抽象方法只有方法的声明,没有方法的实现,本质上是用于子类实现的
  4. 子类继承了抽象类,要么实现抽象类的抽象方法,要么该子类也需要声明为抽象类,需要继续向下继承。

1.7 接口

tips:

  1. 接口可以多继承,本质上是一种约束,不可以被实例化,没有构造方法
  2. 对比普通类、抽象类和接口
类别 特性
普通类 具体实现方法
抽象类 具体实现方法和抽象方法都有,局限是只能单继承
接口 只有规范,不能写方法
  1. 声明接口的关键字是”interface",IDEA中标签为绿色的大写I
public interface 接口名{

}

JAVA基础笔记——对象、异常、static总结_第20张图片

  1. 接口中的方法是隐式定义为public abstract的,常量隐式定义为public static final的,不可修改。
  2. 实现接口的类,必须要重写接口中的所有方法
  3. 实现接口的类增加关键字 implements;多继承时,接口名通过都好隔开
public class 类名 implements 接口名1,接口名2{

}

1.8 内部类

简记科普,后续再打补丁

1.8.1 成员内部类

tips:

  1. 可以获得外部类的私有属性
  2. example:内部类Inner,外部类Outer,通过内部类调用外部类的私有属性
    1)类的代码
public class Outer {
    private int id=10;

    public Outer() {
    }

    public Outer(int id) {
        this.id = id;
    }
    public void out(){
        System.out.println("外部类的方法");
    }
    public class Inner{
        public void in(){
            System.out.println("内部类的方法");
        }
        //内部类获得外部类的私有属性
        public void getID(){
            System.out.println(id);
        }
    }
}

2)运行代码Application.java

package oop;

public class Application {
    public static void main(String[] args) {
        Outer outer=new Outer();//初始化外部类
        Outer.Inner inner=outer.new Inner();//初始化内部类
        inner.getID();

    }
}
  1. 一个java类中可以有多个class类,但是只能有一个public class类
  2. 在其他class类中可以写测试代码(但最好用Application.java单独做一个文件)

1.8.2 静态内部类

tips:
1.静态内部类不能取外部类的私有属性,因为静态先生成
2.相比成员内部类,增加一个static修饰词

1.8.3 局部内部类

tips:

  1. 在外部类的方法中写内部类
  2. example:
public calss Outer{
	public void method(){
		class Inner{
			public void in(0{

			}
		}
	}
}

1.8.4 匿名内部类

tips:

  1. 没有名字初始化类,不用将实例保存在内存中。
  2. example:
new Outer().out();

二、static的总结

2.1 类中的static

tips:

  1. 静态属性变量: 可以用对象名或者类名调用。主要用于多线程。
    example:
    1)Person类
public class Person {
    private  String name;
    public static int nom;

    public Person() {
    }
}

2)测试代码Application.java

public class Application {
    public static void main(String[] args) {
        Person personVar=new Person();
        int nom=personVar.nom;//对象名调用
        nom=Person.nom;//类名调用
    }
}
  1. 静态方法
    在一个类中,非静态方法可以直接通过方法名调用静态方法;静态方法不可以直接调用非静态方法

  2. 静态代码块
    1)只会执行一次
    2)语法结构

public class Person
{
	static{
	//静态代码块
	}
}

3)example:静态代码块、匿名代码块、构造方法执行顺序:静态代码块执行一次,之后每次new新对象,执行匿名代码块和构造方法。

public class Teacher{
    {
        System.out.println("匿名代码块");
    }
    static{
        System.out.println("静态代码块");
    }

    public Teacher() {
        System.out.println("构造方法");
    }

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

JAVA基础笔记——对象、异常、static总结_第21张图片

2.2 静态导入包

tips:

  1. 作用:调用时通过方法名random()直接调用,而不通过Math.random()
  2. 语法结构:
import static java,lang.Math.random;

三、异常

简记科普,后续再打补丁

3.1 异常定义和体系结构

tips:

  1. 分类
名称 定义
检查性异常 最具代表性的是用户错误或问题引起的异常,无法被遇见,在编译时不能被简单忽略
运行时异常 可能被程序员避免的异常,在编译时会被忽略
错误 错误不是异常,是脱离程序员控制的问题,如栈溢出,在编译时无法报错
  1. Java 把异常当初对象来处理 ,定义了一个基础类java.lang.Throwable作为所有异常的超类。
  2. 区分错误Error和异常Exception
    1)Error:灾难性的致命错误,程序无法控制和处理,JVM一般会选择终止线程
    2)Exception:通常情况是可以被程序处理的,并且在程序中应该尽可能的去处理。
  3. 异常的类型和大小关系
    JAVA基础笔记——对象、异常、static总结_第22张图片
  4. 异常中重要的分支运行时异常,包含数组下标越界、空指针、算数异常、丢失资源、找不到类等,一般是由于程序逻辑错误引起的,从逻辑进度应该尽量避免可以在程序中选择捕捉,也可以不处理

3.2 捕获异常

tips

  1. 捕获异常相关的关键字
关键字 用法
try 监控区域
catch 捕获异常,括号内是希望捕获的异常类型 ,可以写多个catch捕获多个异常,要将异常类型最小的写在最前面,层层递进
finally 无论是否捕获到异常都会执行,在try-catch-finally中,finally可以没有,但主要用于IO流时关闭资源
  1. 语法结构:
try{

}catch( 异常类型 异常名称1){


}catch(异常类型  异常名称2){

}
finally{


}

  1. IDEA捕获异常快捷键Ctrl+Alt+T,选中需要监管的语句,按下快捷键,选择try-catch-finally
    JAVA基础笔记——对象、异常、static总结_第23张图片
    JAVA基础笔记——对象、异常、static总结_第24张图片

3.3 抛出异常

tips:

  1. 抛出异常一般用于方法中,当该方法处理不了异常,可以将异常抛出
  2. 抛出异常关键字
关键字 作用
throw 在方法内
throws 在声明方法时
  1. 语法结构
public void 方法名(形参表) throws 异常类型{
	//代码块
	throw new 异常类型();
}

3.4 自定义异常

tips:

  1. Java内置异常类已经可以处理大部分情况,但用户可以通过继承Exception类来自定义异常

  2. 自定义异常类步骤:
    1)创建自定义异常类
    2)在方法中通过throw抛出异常对象
    3)如果在抛出异常的方法中处理异常,则使用try catch语句捕获处理;否则通过throws指明要抛出给方法调用者的异常
    4)在方法调用处捕获并处理异常

  3. example:
    1)自定义异常类myException

public class myException extends Exception{
    private int detail;

    public myException(int detail) {
        this.detail = detail;
    }

    public String toString(){
        return "myException("+detail+")";
    }
}

2)测试类test

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(1);
        } catch (myException e) {
            System.out.println("myException=>"+e);
        } finally {
        }
    }
}

3)结果
a<=10
JAVA基础笔记——对象、异常、static总结_第25张图片
a>10
JAVA基础笔记——对象、异常、static总结_第26张图片

你可能感兴趣的:(java笔记,java)