目录
一、static
1、修饰成员变量
2、修饰成员方法
二、工具类
三、代码块
1、静态代码块
2、实例代码块(构造代码块)
四、单例模式
1、饿汉单例模式
2、懒汉单例模式
五、extends
1、继承的特点
2、在子类方法中访问成员变量，成员方法的访问特点
3、方法重写
4、子类构造器的特点
5、子类构造器访问父类的有参构造器
6、this和super
一、static
static修饰，归属于类，与类一起加载，可以被共享访问
无static修饰，归属于对象
1、修饰成员变量
（1）静态成员变量：如果有信息要被共享，只需要一份就够
可以类名访问（建议），同一个类中访问静态成员变量可以省略类名
可以对象访问（不推荐）
public class Test {
public static int numbers = 100;
public static void main(String[] args) {
System.out.println(numbers);
System.out.println(Test.numbers);
Test t = new Test();
System.out.println(t.numbers);
}
}
（2） 实例成员变量：每个对象都有这些信息，且信息不同
只能对象访问
public class Test {
private int numbers=100;
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.numbers);
}
}
2、修饰成员方法
（1）静态成员方法：执行一个公共功能为目的
可以类名访问（建议），同一个类中访问访问静态成员方法可以省略类名
可以对象访问（不推荐）
public class Test {
public static void method(int n){
System.out.println(n);
}
public static void main(String[] args) {
method(1);
Test.method(1);
Test t = new Test();
t.method(1);
}
}
静态方法只能访问静态成员/方法，不可以直接访问实例成员/方法，不可以出现this关键字
public class Test {
public static int numbers1 = 100;
private int numbers2;
public static void method(){
System.out.println(numbers1); //正常
System.out.println(numbers2); //报错
Test t = new Test();
t.numbers2=100;
System.out.println(t.numbers2); //正常
System.out.println(this); //报错
}
public static void main(String[] args) {
method();
}
}
（2）实例成员方法：表示对象自己的行为的，而且该方法需要直接访问对象的实例成员
只能对象访问
public class Test {
public void method(int n){
System.out.println(n);
}
public static void main(String[] args) {
method(1); //报错
Test.method(1); //报错
Test t = new Test(); //正常
t.method(1);
}
}
实例方法可以访问静态成员/方法，也可以访问实例成员/方法
public class Test {
public static int numbers1 = 100;
private int numbers2 = 100;
public void method(){
System.out.println(numbers1); //正常
System.out.println(numbers2); //正常
Test t = new Test();
t.numbers2=100;
System.out.println(t.numbers2); //正常
System.out.println(this); //正常
}
public static void main(String[] args) {
Test t = new Test();
t.method();
}
}
二、工具类
工具类中都是一些静态方法，每个方法都是以完成一个共用的功能为目的
直接用类名即可访问，无需创建对象，建议将工具类的构造器私有
三、代码块
定义在类中，方法外，{}括起来的代码
1、静态代码块
static{} 特点：随着类加载而加载，并自动触发执行一次，并且在main方法执行前执行
在类加载的时候做一些静态数据初始化的操作，以便后续使用
public class Test {
public static int n;
static {
System.out.println(1);
n=3;
}
public static void main(String[] args) {
System.out.println(2);
System.out.println(n);
}
}
2、实例代码块(构造代码块)
{} 特点：每次创建对象调用构造器执行，都会执行该代码块中的代码，并且在构造器执行前执行
初始化实例成员
public class Test {
private int n;
public Test(){
System.out.println(2);
}
{
System.out.println(1);
n=3;
}
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.n);
}
}
四、单例模式
可以保证系统中应用该模式的这个类永远只有一个实例，即一个类只能创建一个对象
1、饿汉单例模式
在用类获取对象的时候，对象已经提前为你创建好了
（1）定义一个类，把构造器私有
（2）定义一个静态变量存储一个对象
public class Test1{
public static Test1 t = new Test1();
private Test1(){
}
}
public class Test {
public static void main(String[] args) {
Test1 t1 = Test1.t;
Test1 t2 = Test1.t;
System.out.println(t1==t2);
}
}
输出结果：
true
2、懒汉单例模式
正在需要该对象的时候，才去创建一个对象（延迟加载对象）
（1）定义一个类，把构造器私有
（2）定义一个静态变量存储一个对象
（3）提供一个返回单例对象的方法
public class Test2 {
private static Test2 t;
private Test2(){
}
public static Test2 getInstance(){
if(t==null){
t=new Test2();
}
return t;
}
}
public class Test {
public static void main(String[] args) {
Test2 t1 = Test2.getInstance();
Test2 t2 = Test2.getInstance();
System.out.println(t1==t2);
}
}
输出结果：
true
五、extends
子类 extends 父类 Text1为子类（派生类），Test2为父类（基类，超类）
public class Test {
public static void main(String[] args) {
Test2 t = new Test2();
t.run();
}
}
public class Test1{
public void run(){
System.out.println(1);
}
}
public class Test2 extends Test1{
}
1、继承的特点
（1）子类可以继承父类的成员变量和方法，但是子类不可以继承父类的构造器
（2）单继承：一个类只能继承一个直接父类
（3）支持多层继承
（4）所有的类都是Object类的子类：java中所有类，要么直接继承了Object，要么默认继承了Object，要么间接继承了Object，Object是祖宗类
2、在子类方法中访问成员变量，成员方法的访问特点
（1）就近原则
（2）super关键字：指定访问父类的成员 super.父类的成员变量/父类的成员方法
public class Test {
public static void main(String[] args) {
Son t = new Son();
t.run();
}
}
class Father {
int a = 3;
public void out(){
System.out.print(5);
}
}
class Son extends Father{
int a = 2;
public void out(){
System.out.print(4);
}
public void run(){
int a = 1;
System.out.print(a);
System.out.print(this.a);
System.out.print(super.a);
out();
super.out();
}
}
输出结果： 12345
3、方法重写
子类中出现了和父类中一模一样的方法声明，称子类的这个方法为重写的方法
（1）私有的方法不能重写
（2）静态的方法不能重写
（3）重写方法的名称，形参列表必须与被重写方法的名称，形参列表一致
（4）子类重写父类方法时，访问权限必须大于或等于父类
（5）@Override：重写注解，放在重写的方法上，如果出现错误，会错误提示
public class Test {
public static void main(String[] args) {
Son t = new Son();
t.run();
}
}
class Father {
public void run(){
System.out.println(1);
}
}
class Son extends Father{
@Override
public void run(){
super.run();
System.out.println(2);
}
}
4、子类构造器的特点
子类中所有的构造器默认都会先访问父类构造器中的无参构造器
子类构造器的第一行语句默认都是 super(); 不写也存在，默认找父类的无参构造器执行
public class Test {
public static void main(String[] args) {
Test2 t1 = new Test2();
Test2 t2 = new Test2(2);
}
}
public class Test1 {
public Test1() {
System.out.print(1);
}
}
public class Test2 extends Test1{
public Test2() {
super();
System.out.print(2);
}
public Test2(int n){
super();
System.out.print(n);
}
}
5、子类构造器访问父类的有参构造器
通过调用父类有参构造器来初始化继承自父类的数据 super.(变量)；
public class Test {
public static void main(String[] args) {
Test2 t = new Test2(1);
}
}
public class Test1 {
private int n;
public Test1() {
}
public Test1(int n) {
this.n = n;
}
public int getN() {
return n;
}
public void setN(int n) {
this.n = n;
}
}
public class Test2 extends Test1{
public Test2(int n){
super(n);
}
}
6、this和super
（1）this：代表本类对象的引用
访问本类成员变量：this.成员变量;
访问本类成员方法：this.成员方法;
访问本类构造器：this() ;
（2）super：代表父类存储空间的标识
访问父类成员变量：super.成员变量;
访问父类成员方法：super.成员方法;
访问父类构造器：super() ;
（3）this访问本类构造器
this() 和 super() 都只能放在构造器的第一行，所以二者不能共存在同一个构造器中
子类通过this()去调用本类其他构造器，本类其他构造器会通过super()去调用父类的的构造器
public class Test {
public static void main(String[] args) {
Test1 t = new Test1(1);
System.out.println(t.getN());
System.out.println(t.getM());
}
}
public class Test1 {
private int n;
private int m;
public Test1(int n){
this(n,2);
}
public Test1() {
}
public Test1(int n, int m) {
this.n = n;
this.m = m;
}
public int getN() {
return n;
}
public void setN(int n) {
this.n = n;
}
public int getM() {
return m;
}
public void setM(int m) {
this.m = m;
}
}
