学习JavaDay09

复习Day08

面向对象三大特征

封装
	作用:
		封装一段代码;
	优点:
		1.降低耦合度
		2.增加代码的利用率
		3.保护内部
	封装的体现:
		变量
		方法
		数组
		类
		包
		...
	包:package
		com.jlf.mypackage
	导包
	访问权限修饰符
    	public:			同一个项目下可以使用;
    	private: 		在当前类下可以使用;
    	protected:	 	继承关系中,当前包中;
    	不写:			   当前包中可以使用;
继承
	含义:继承父类所有属性与方法;
	关键字:
		extends: 
			含义:继承
		super:
			含义
				谁调用super所在的方法,super就代表谁的父类对象.
			作用:
				1.当父类成员方法与属性与子类重名时,用于区分子类与父类
					super.属性名/方法名(实参列表)
				2.调用父类构造函数
					语法:
						super(实参列表)
						不能形成递归
						要放在第一行
					注意:
						1.如果子类构造函数中有调用父类构造函数,系统将不在调用父类构造函
						数,
						2.如果子类构造函数中有调用父类构造函数,那么系统奖不在为其调用父类构造函数
						3.如果子类没有调用父类构造函数,父类没有无参构造,子类构造函数将会报错
						
				3.调用父类的属性与方法.this与super都可以调用
					super.属性名/方法名(实参列表)
		1.Java是单继承,一个子类只能继承一个父类;
		2.所有类都继承了Object类;
		3.继承时,要分析是否有继承关系;
	语法:
		访问权限修饰符 class 子类名 extends 父类名{
			继承了父类的所有属性与方法,构造函数除外;
			子类特有属性;
			子类特有方法;
			子类构造函数;
		}
	
多态:
	含义:
		一个事物的多种形态;
	重载:
		1.在同一个类中
		2.方法名相同
		3.形参列表不同
	重写
		1.在继承关系同,子类方法中访问权限修饰时符大于父类中访问权限修饰符.
		2.返回值类型相同
		3.方法名相同
		4.形参列表相同
		5.方法体不同
		
	物的多态
		1.子类对象转换成父类对象(自动类型转换)<小转大>
		
			1.转换后的父类对象,不能调用子类特有的方法.
			2.转换后的父类对象,调用子类重写的方法,执行的还是子类重写的方法.
		2.父类对象转换为子类对象(强制类型转换)<大转小>
			如果不是该类对象,就会发生类型转换异常.
			可能会发生类型转换异常 ClassCastException.
	需要转换时的方法:
		利用intanceof 关键字
			作用:
				判断该对象是否属于该类
			语法:
				boolean b = 对象名 intanceof  类名;
                如果b的结果为true,则该对象属于该类.
                如果b的结果为假,则该对象不属于该类.
	

Day09

三大修饰符

代码块:
	作用是封装一段代码
	语法:
		{}
	定义位置:
		1.方法中
			不影响代码运行,写了和不不写一样
		2.类中,方法外.
				每次创建该类对象时调用,而且在在构造函数之前.属性赋初始值之后
			注意:
				1.每次创建对象时都会执行代码块中的代码
				2.在构造函数之前执行.
				3.在对象赋初值之后执行.
举例:
	代码如下:
//主函数	
public class Main {
	public static void main(String[] args) {
		//普通代码块1
		{
			System.out.println("主函数中普通代码块1,被调用");
		}
		//创建A类对象
		A a = new A();
		//普通代码块2
		{
			System.out.println("主函数中普通代码块2,被调用");
		}	
	}
}	
//类A
class A {
	//A的无参构造函数
	public A() {
		System.out.println("A的无参构造函数,被调用");
	}
	//普通代码块
	{
		System.out.println("A类中普通代码块,被调用");
	}
	//静态代码块
	static {
		System.out.println("A类中静态代码块,被调用");
	}
}

static :静态
	可以修饰的东西
	属性:
		含义:公有的
			static修饰的的的属性属于整个类的所有对象,如果其中一个对其修改,那么该类的所有对象的该属性都将被修改.
			语法:
				类名.属性名
				或
				对象名.属性名
			注意:static修饰的属性,不管创建了该类的多少个对象,单该属性只有一个.
	方法:
		含义:静态方法
		使用方法
		类名.方法名(实参列表);
		或
		对象.方法名(实参列表)
		static 修饰方法
			静态方法中,不能使用非静态成员(就是没有关键字static修饰的方法和属性)
	代码块:
		名称:静态代码块
		调用机制:JVM加载类的时候,会调用.
			由于一个类只会被加载一个,所以该代码块只会被执行一次.
			语法
				static{
					代码块;
				}
	内部内:
	
	
什么时候会加载类:
	1.使用类名调用静态属性或方法时
	2.创建该类对象时.
	3.创建其子类对象时.
	4.获取类对象时
在静态下对象的创建过程:
	总结先静态,后非静态.
	1.加载该类
	2.给静态属性赋初始值
	3.执行静态代码块中的代码
	4.使用new在堆内存中开辟空间
	5.给非静态属性赋初始值
	6.执行代码块中的代码
	7.执行构造函数中的代码
	8.将new在堆内存中开辟的地址,赋值给栈的引用.


abstract:(抽象的)
	修饰的内容有:
		类
			使用abstract修饰的类,称为抽象类
		方法
			使用abstract修饰的方法,称为抽象方法
	抽象类:
		不能直接创建对象
			语法:
				访问权限修饰符 abstract class 类名 extends 父类名{
			
				}
		不能创建类对象
		除了不能创建类对象以外,其他和普通类一样
	抽象方法:
		**没有方法体**
			语法:
				访问权限修饰符 abstract 返回值类型 方法名(形参列表);
		注意:
			1.有抽象方法的类,一定是抽象类,但抽象类不一定有抽象方法
			2.子类继承抽象类,要么重写所有抽象方法,要么自己也是抽象类;


final:(最终不可修改的)
	可以修饰的东西有;
		类(最终类:)
		特点:
			不能被其他类继承
		语法:
			访问权限修饰符 final class 类名{
				类中有:
				属性
				方法
				构造函数
			}
		变量
			final修饰的变量为常量,不能被修改
		方法
			语法:
				访问权限修饰符 final 返回值类型 方法名(形参列表){
					//fianl修饰的方法不能被重写,
				}
	可以修饰的变量:
		特点:
			1.final修饰的变量不能被修改
			2.final修饰的变量又称为常量,
			
		成员变量:
			语法:
				访问权限修饰符 final 数据类型 属性名 = 值;
			注意:
				1.必须在声明时赋值
				2.属性值不能被修改
		局部变量:
			语法:
				fianl 数据类型 变量名 = 值;
				1.可以将声明与赋值分开,但是只能赋值一次;
			注意常量名要全大写
	修饰的方法:
		特点:
			**不能被重写;
		语法:
			访问权限修饰符 final 返回值类型 方法名(形参列表){
			
			}
			
abstract 和 final 都可以修饰类或方法:
	abstract可以修饰:类,方法;
	final 类,方法,属性,变量;
	1.abstract修饰的类是为了让其他类继承,而final修饰的类是不让其他类继承,两者相互矛盾,所以不能同时使用
	2.abstract修饰的方法为抽象方法,是为了让子类重写,但是final修饰的方法不能重写,相互矛盾,所以不能同时使用.

abstract 与 static 不能一起使用	

案例

//记录一个类的创建次数:
//	代码块中统计:
public class text {
	public static void main(String[] args) {
		System.out.println("没有创建对象num:"+A.num);
		A a = new A();	
		A a1 = new A();
		A a2 = new A();
		A a3 = new A();		
		System.out.println("创建了"+A.num+"次对象,num的值为"+A.num);
	}
}
class A {
	public static int num = 0;
	{
		num++;
	}
}