java面向对象

类与对象

        类是一个模板：抽象，对象是一个具体的实例
    2.方法
    定义，调用：
    3.对象的引用
    引用类型：基本类型（8）
    对象是通过引用来操作的：栈-->堆
    4.属性：字段Field 成员变量
    默认初始化：
    数字：0  0.0
    char：u000
    boolean:false
    引用：null
    修饰符  属性类型 属性名 = 属性值！
    5.对象的创建和使用
    - 必须使用new 关键字创造对象，构造器 Person xm = new Person()
    - 兑现属性 xm.name
    - 对象的方法 xm.sleep()
    6.类：
    静态的属性  属性
    动态的方法  方法

super注意点：
1.super调用父类的构造方法，必须在构造方法的第一个
2.super,必须只能出现在子类的方法或者构造方法中
3.super和this 不能同时调用构造方法
Vs this
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提
this：没有继承也可以使用
super：只能在继承条件下使用
构造方法
this();本类的构造
super();父类的构造

方法重写：需要有继承关系, 子类重写父类

1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大 Public>Protected>Default>Private
4.抛出异常：范围可以被缩小，但不能扩大；ClassNotFoundException --> Exception

重写，子类的方法和父类必须一致：方法体不同！

为什么需要重写:
1.父类的功能，子类不一定需要，或者不满足！
Alt + Insert + override

多态：

1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常 ClassCastException!
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象

类型转换

1.父类引用指向子类的对象
2.把子类转换为父类，向上转型
3.把父类转换为子类，向下转型：强制转换
4.方便方法的调用，减少重复的代码！

抽象：封装、继承、多态

static的作用范围及用法

1- 修饰类的成员:
静态变量：某些特定的数据在内存中只有一份，而且能被一个类的所有实例对象共享。可以使用类名.变量名的形式来访问。当然也可以先实例化对象在用对象.变量名访问
注意： static关键字只用于修饰 成员变量，不能用于修饰局部变量

2- 静态方法：可以在不创建对象的情况下调用某个方法，使方法和对象解绑。用类名.方法名（） 来调用方法
注意： 静态方法中 只能访问用static 修饰的成员，因为非静态成员需要创建对象才能访问，但静态方法被调用时可以不创建对象，此时会矛盾。

3- 静态代码块:当类被加载时，静态代码块会执行一次，因为一个类只加载一次，所以静态代码块只执行一次。通常使用静态代码块对类的成员变量进行初始化。
注意： 在静态代码块中只能访问static修饰的成员
4- 静态内部类：在类的内部定义一个类，用static修饰。可以在不创建外部类对象的情况下被实例化
创建静态内部类的语法格式:
外部类名.内部类名 变量名=new 外部类名.内部类名()

class Outer{
	private static int num=6;
	static class Inner{
		void show(){
			System.out.println("num="+num);
		}
	}
}
public class Demo{
	public static void main(String[] args){
		Outer.Inner inner=new Outer.Inner();//创建内部类对象
		inner.show();
	}
}
 

static关键字的应用—单例模式

class Single{
	private Single(){}//私有化构造方法
	private static Single INSTANCE=new Single();//创建一个对象
	public static Single getInstance(){//提供返回该对象的静态方法
	return INSTANCE;
	}
}
public class Demo{
	public static void main(String[] args){
		Single s1=Single.getInstance();//利用getInstance()方法获取实例对象
		Single s2=Single.getInstance();
		System.out.println(s1==s2);//结果是 true，表明引用同一对象。
		}
}
	
 

从上边代码可以看出单利模式的特点：
1.构造方法私有化private：这样就不能在类外部使用new来创建实例对象了
2.在类内部有实例化对象： 在类内部创建一个该类的实例对象，并用静态变量引用该对象（为了能在getIntence()方法中访问该变量），再加上private修饰，这样可以禁止外界直接访问变量
3.设有外部获取Single类实例对象的唯一方法： 为了让类外部能获得类的实例对象，定义静态方法getInstance()（可以通过类名.方法名来访问）

关于静态变量、静态方法、静态内部类使用的注意事项

1.static方法：方法体内可以调用其他静态方法，不能调用非静态方法；只可以访问方法外部的static变量；不能定义静态变量，可以定义非静态变量。
2.非static方法：方法体内部不能定义static变量；能调用static方法；能调用非static方法。
3.static关键字只能用于修饰成员变量，不能修饰局部变量（如形参、方法体内部变量）。
4.静态内部类中只能访问外部类的静态成员
5.静态内部类中可以定义静态成员，而非静态的内部类中不允许定义静态成员
从上面的几条注意事项可以看出，静态好像总是与非静态处于一种不包容的关系。其实这是因为在类加载时，静态属性也会开始加载，而非静态的属性只有在类加载完成后才开始初始化，开始实例对象。这就导致static可以直接用，而非static的还要先创建对象才能使用，如果二者混在一起，会产生矛盾。

抽象类

 1.有抽象方法的类一定是抽象类
 2.是抽象的类不一定要有抽象方法
 3.法通过new实例，通过继承
 4. 子类必须实现所有的父类抽象方法，否则也要注明abstract

abstract抽象类存在构造器吗？

存在！！！虽然抽象类没有提供任何构造函数，编译器将为抽象类添加默认的无参数的构造函数，如果没有的话抽象类的子类将无法编译，因为在任何构造函数中的第一条语句隐式调用super（）。

抽象类存在的意义是什么？

抽象类存在的意义是被子类继承，否则抽象类将毫无意义，抽象类体现的是模板思想，模板是通用的东西 抽象类中已经是具体的实现（抽象类中可以有成员变量和实现方法），而模板中不能决定的东西定义成抽象方法，让使用模板（继承抽象类的类）的类去重写抽象方法实现需求，这是典型的模板思想。

抽象方法有什么意义？

抽象方法是在抽象类里的,首先,一个子类如果是继承一个抽象类，如果该子类是非abstract类，就必须实现基类中的所有抽象方法。
之所以需要继承，是因为这个方法是这些子类的一个共同属性。或者说，父类要通过这些抽象的方法，提供某种特定的服务，但是实现方式在子类中有所不同，所以在父类中写了抽象方法强制子类实现，保证能够提供这种服务。

接口

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法，Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

异常处理的经验总结

1.处理运行时异常，采用逻辑去合理规避同事辅助 try-catch处理
2.在多重catch块后面，可以加一个catch（Exception）来处理可能会被遗漏的异常
3.对于不确定的代码，也可以加上try-catch，处理潜在的异常
4.尽量去处理异常，切忌只是简单的调用printStackTrace（）去打印
5.具体如何处理异常，要根据不同的业务需求和异常类型去决定
6.尽量添加finally语句块释放占用的资源