• javabean类：用于描述一类事物的类
• 测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的主入口
• 工具类：不是用来描述一类事物，而是帮我们做一些事情的类
  工具类通常需要私有化构造方法，因为创建它的对象没有意义
  工具类通常使用static修饰方法
  静态方法只能访问静态变量和静态方法
  静态方法中没有this关键字

用来描述一类事物的类，专业叫做：Javabean类。 在Javabean类中，是不写main方法的。 在以前，编写main方法的类，叫做测试类 我们可以在测试类中创建javabean类的对象并进行赋值调用。

一个java文件中可以定义多个class类，且只能有一个类是public修饰，而且public修饰的类的类名必须是文件名

继承

java不允许多继承,但允许多层继承 Java中提供一个关键字extends，用这个关键字，我们可以让一个类和另一个类建立起继承关系。

public class Student extends Person {}

Student称为子类（派生类），Person称为父类(基类或超类)。

子类能够继承父类的内容

• 构造方法: 不管是不是private修饰符修饰的都不能继承
• 成员变量: 不管是不是私有都可以被继承,但私有的无法访问
• 成员方法: 非私有的能继承,私有的不能继承

父类的构造方法不会被子类继承
子类中所有构造方法默认先访问父类的无参构造再执行自己
这是防止子类初始化是可能会用到从父类那里继承来的数据
需要在子类的构造方法中第一行显式写出super（）
不写也是存在的，显式写出来必须在第一行
如果想要调用父类的有参构造必须手动写super调用

super指针

和this指针类似,super指针代表的是父类 但子类中只能调用一次super,在子类中只能调用一个父类,所以无法使用super调用到父类的父类

重写

只有添加到虚方法表中的方法才可重写 在继承体系中，子类出现了和父类中一模一样的方法声明，我们就称子类这个方法是重写的方法。 方法名和形参列表必须一致 但返回值类型可以不一致,但返回值类型子类必须小于等于父类 ( 即如果返回值是继承的父子类,父类函数的返回值是另一个继承关系子类时,子类重写的返回值不能是那一个继承关系的父类)

错误:

class Animal{}
class Dog extends Animal{}

class A{
	public Dog func(){}
}

class B extends A{
	@Override
	public Animal func(){}
}

子类重写父类的方法时,访问权限子类必须大于等于父类(public>protected>无) 私有方法不能被重写 子类不能重写父类的静态方法，如果重写会报错的。

@Override重写注解

@Override是放在重写后的方法上，校验子类重写时语法是否正确。

class A{
	public void func(){}
}

class B extends A{
	@Override
	public void func(){}
}

在一个类的构造函数中可以调用它的其他的构造函数,但这样只能写在第一行,否则会报错 放在第一行后如果有父类的话编译器会进行优化即在此构造中不调用super()无参构造,而在子类调用的构造方法里调用super()

public class Student{
	String name;
	int age;
	String school;
	
	public Student(){
		this(name,null,"hello");    //调用其他的构造函数,必须放在第一行
		System.out.println("1234");
	}
	public Student(String name,int age,String school{
		this.name=name;
		this.age=age;
		this.school = school;
	}
}

判断类型: x instanceof T判断x是不是T类型,返回布尔值 java14新特性 x instanceof T y如果x是T类型则将其转换为T类型后保存为y变量,如果不是T类型就返回false

包

公司域名反写+包的作用，需要全部英文小写，见名知意。如: com.itheima.domain

管理类的文件夹用来管理各种不同功能的Java类，方便后期代码维护.相当于命名空间

使用其中的Student类

con.itheima.domain.Student s=new com.itheima.domain.Student();

import con.itheima.domain.Student;

final

修饰方法表明该方法时最终方法不能被重写

修饰类表明该类时最终类,不能被继承

修饰变量表明这个变量代表常量,只能被赋值一次,以后都不可被修改 基本数据类型：变量的值不能修改 引用数据类型：地址值不能修改，内部的属性值可以修改

权限修饰符

四种权限作用范围由小到大 private<默认 ( 缺省 ) <protectedd< public 默认也就是不写明权限修饰符

权限可用的范围

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	Y
default	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

构造代码块

public class Student {
	private String name;
	private int age;
	{
		System.out.println("开始创建对象了");
	}
	public Student(){}
	public Student (String name,int age){
		this.name=name;
		this.age=age;
	}
}

把构造函数都会用到的代码以代码块的方式写到成员变量区里面,这样就不用写重复的代码了,相当于委托构造函数

静态代码块

需要通过static关键字修饰，随着类的加载而加载，并且自动触发、只执行一次

static{
	/*code*/
}

抽象类

abstract关键字 被abstract修饰的成员函数可以不给出实现只给出声明,其子类继承后必须重写此函数否则会报错

被abstract修饰的类就是抽象类

• 抽象类不能实例化
• 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
• 可以有构造方法
• 抽象类的子类 要么重写抽象类中的所有抽象方法 要么是抽象类

接口

接口是对行为的抽象 public interface 接口名{} 接口不能实例化 接口和类之间是实现关系，通过implements关键字表示 public class 类名 implements 接口名{}表明该类对此接口进行实现 接口的子类也被称为实现类: 要么重写接口中的所有抽象方法 要么是抽象类

接口和类的实现关系，可以单实现，也可以多实现。

public class 类名 implements 接口名1,接口名2{}

实现类还可以在继承一个类的同时实现多个接口。

public class 类名 extends 父类 implements 接口名1,接口名2{}

接口中的成员变量只能是常量,没有构造方法,成员方法只能是抽象方法

接口和接口之间的关系可以是单继承也可以是多继承,如果类实现的是最下面的子接口时就需要实现它上面的所有抽象方法

因为接口重写时需要实现其中的所有抽象方法,若要对接口进行更改那么继承这个接口的所有类也要更改

默认方法

再jdk8之后就允许接口中定义默认方法,需要使用到default关键字修饰用来解决接口升级的问题 默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字 如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

静态方法

接口中使用static修饰的成员方法

静态方法只能通过接口名调用，不能通过实现类名或者对象名调用 ( 静态方法不在虚方法表中所以无法被继承 )

私有方法

私有方法是提供给接口内部使用的,不会被继承

内部类

成员内部类

在一个类的内部再定义一个类这个类就是内部类

内部类表示的事物是外部类的一部分 内部类单独出现没有任何意义

内部类可以直接访问外部类的成员，包括私有 外部类要访问内部类的成员，必须创建对象

jdk16之前内部类无法定义静态成员,jdk16之后可以

静态内部类

在内部类前加static修饰 静态内部类只能访问外部类中的静态变量和静态方法，如果想要访问非静态的需要创建对象。 通过外部类.内部类调用

public class Outer {
    public static class Inner {
        public void createInner() {
            System.out.println("Inner");
        }
    }
}

    Outer.Inner oi=new Outer.Inner();
    oi.createInner();

• 非静态方法：先创建对象，用对象调用
• 静态方法：外部类名.内部类名.方法名();

局部内部类

将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部变量外界是无法直接使用，需要在方法内部创建对象并使用。该类可以直接访问外部类的成员，也可以访问方法内的局部变量。

匿名内部类

new 类名或接口名(){
	重写方法;
};

示例:

class Test externs Swim{
	new Swim(){
		@Override
		public void swim(){
			System.out.println("重写了游泳的方法");
		}
	}
};

其中new后面的Swim是表示创建了一个类的对象,它后面的大括号中的代码段才是类,大括号中的内容和被继承的类(Swim)是继承关系,即new Swim()后面的大括号是Swim类的子类,如果Swim是接口的话那二者就是实现关系 如上所述,可以使用一个变量接受匿名内部类的对象,也可之间使用匿名内部类的对象调用方法 ,上面的代码只是重写了匿名内部类,但还没有调用

class Test externs Swim{
	Swim s = new Swim(){
		@Override
		public void swim(){
			System.out.println("重写了游泳的方法");
		}
	}
};

或:

class Test externs Swim{
	new Swim(){
		@Override
		public void swim(){
			System.out.println("重写了游泳的方法");
		}
	}.swim();
};

贡献者

pinkdopeybug

版权所有

版权归属：PinkDopeyBug

许可证：署名 4.0 国际 (CC-BY-4.0)