代码块,内部类,多态学习笔记----Java

静态继承总结

1. 静态的好处:在类中实例化所个对象,对象的属性值相同,不会再堆内存中反复开辟空间,只会在方法的静态区间开辟,节省内存空间,修改变量值的时候比较简单.
2. 静态方法不可以调用非静态的属性或方法.
3. 静态方法与成员变量的区别:
   静态变量有称类变量;成员变量称为对象变量;
   静态变量随着类的加载而加载;成员变量随着对象的创建而创建;
   静态变量存在方法区的静态区间;成员变量存在堆中;
   调用方法静态变量=>类名.属性名 成员变量=>对像名.属性
4. 对数组工具类封装,提供一些静态的方法 直接通过类名.方法名调用;
5. 生成帮助文档,用于查看类的方法,构造,属性的一些描述信息;
6. 文档注释/** 文档注释的注解 */;
7. 查看jdk 的API,用于查看类的方法,构造,属性的一些描述信息;
8. Arrarys常用的静态方法,对数据进行处理;
9. 继承:满足 is a 的关系,才能使用继承,关键字extends;
10. 父类中私有的,构造方法不个继承,但是可以调用构造方法;
11. java只支持单继承,可以多层继承有直接或间接父类;
12. 继承变量的方法原则:就近原则;
13. this, super关键字,this表示当前对象的引用,super表示当前父类对象的引用;
14. 子类的构造方法 this super不能同时存在;
    this super只能在方法够造的第一行
    如果子类没有调用父类的够造方法 系统会默认调用父类的无参构造
15. 继承方法: 子父类 没有重名,先调用子类,子类没有在向上查找
    重名:直接调用子类;
16. 重写:在继承关系中,方法名相同,参数列表相同,与返回值有关;
17. 重写注意事项:方法修饰符权限不能大于父类;返回值类型不能大于父类,私有的方法不能重写

代码块

1. 写在大括号里的一段代码 ｛要执行的代码｝
2. 代码块分类：局部代码块 构造代码块 静态代码块

局部代码块

1. 定义：用{}的代码
2. 位置：在方法中
3. 作用：限制变量的生命周期
4. 代码块随着代码块的执行而开始，随着代码结束而结束内存空间
5. 局部代码块中不是给局部代码的块的变量进行赋值的时候，代码块结束，赋值的效果依然存在

构造代码块

1. 定义:写在大括号内的一段代码;
2. 位置:类中方法外
3. 作用:主要用来给成员变量进行赋值
4. 代码:构造代码块比构造方法先执行;
   构造代码块是由jvm来执行的;
   每实例化对象一次都会先执行构造代码块;
   所有构造方法都需要给成员变量进行赋值的时候,就可以抽取到静态代码块中执行;

静态代码块

1. 格式: static{
   代码
   }
2. 位置:类中方法外;
3. 作用:给静态变量来进行赋值,只加载一次，如加载驱动，某些工具类只需要实例化一次
4. 静态代码块最先进行加载,且只加载一次;

final关键字

1. final 最后,最终,也就是不能再改变的;
2. final 修饰类,方法,变量;
3. final 修饰类 语法: 访问修饰符 final class 类名{}
   注意: final 修饰的类不能不继承,修饰的方法不能被重写;

public final class fu{
//final修饰类,不可被继承
	public final void show(){
//final修饰方法不能被重写;
	}
}

4. 修饰变量 =>变成个常量,不可以再改变;
   特点:使用final修饰的变量只能进行一次赋值,不能再改变;
   使用final修饰引用数据类型,不能改变其地址值,对象属性可以进行改变;

内部类

1. 内部类:定义在类中的类,类可以定义在类中也可以定义在方法中
2. 分类: 成员内部类(普通内部类,私有内部类,静态内部类),局部内部类(定义在方法中的类)

普通内部类

1. 位置:定义在成员变量的位置的类;
2. 格式

class 类名{
	属性;
	方法;
}

3. 说明: 内部类可以获取到外部类所有的资源(包括私有的属性或者是方法);
   外部类要获取内部类的方法或者属性需要进行实例化对象;
   在其他类中实例化内部类语法 : 外部类.内部类 对象名 = new 外部类().new 内部类();

私有的内部类

1. 在普通内部来加上private 关键字;
2. 语法

private class 类名{
	属性;
	方法;
}

3. 说明: 私有的内部类如果外部类组要获取其属性或方法需要进行实例化对象;
   私有的内部类可以获取到外部类中所有的属性或方法;
   其他类如果想访问内部类只有通过内部类的外部类来进行实例化对象来调用其方法;

静态内部类

1. 静态内部类只需要在普通内部类加上static 关键字
2. 语法

static class 类名{
	成员属性;
	方法;
}

3. 说明: 在静态内部类中定义的静态变量,外部类可以直接通过内部类 类名.属性获取;
   静态内部类中非静态变量,外部类必须实例化对象才能获取到;
   在其他类中如果想方位静态内部类中的方法语法 :
   外部类 对象名 = new 外部类.静态内部类();
   对象名.方法;

局部内部类

1. 定义在方法中的内部类
2. 语法

访问修饰符 返回值类型 方法名(){
	class 类名{
		成员属性;
		方法;
	}
}

3. 其他类想调用方法内部类里的方法: 借助于在当前方法中实例化对象并调用内部类中的方法,外外部类才能进行访问(简单说通过方法=>实例化对象=>调用内部类方法)

内部类代码案例

code类

public class Code {
	//定义普通内部类
	class CodeIn{
		public void print3() {
			System.out.println("我是普通内部类");
		}
	}
	//定义静态内部类
	static class CodeInStatic{
		public void print1() {
			System.out.println("我是静态内部类");
		}
		
	}
	//定义私有内部类
	private class CodeInPrivate{
		public void print2() {
			System.out.println("我是私有内部类");
		}
		
	}
	public void show() {
		//实例化私有内部类
		CodeInPrivate codeInPrivate = new CodeInPrivate();
		//调用私有内部类的方法
		codeInPrivate.print2();
		//定义局部内部类
		class CodeInShow{
			public void print() {
				System.out.println("我是局部内部类");
			}
		}
		//实例化局部内部类
		CodeInShow codeInShow = new CodeInShow();
		//调用局部内部类的方法
		codeInShow.print();
	}
	
	static {
		System.out.println("我是静态代码块");
	}
	{
			System.out.println("我是构造代码块");
	}
	
}

测试代码

public class CodeTest {
	public static void main(String[] args) {
		Code.CodeIn codeIn= new Code().new CodeIn();//普通内部类
		codeIn.print3();//普通内部类调用方法
		Code.CodeInStatic codeInStatic = new Code.CodeInStatic();//静态内部类
		codeInStatic.print1();//静态内部类的方法
		Code code = new Code(); //私有内部类,局部内部类
		code.show();//调用私有内部类方法,局部内部类方法
		
	}
	

}

运行结果

包

1. 包主要用于存放java代码,源代码;
2. 作用: 存放java代码,对代码进行分类管理,类似于文件夹的作用;
   在不同的包中可以定义重复类;
3. 命名规则: 域名 + 公司名 + 项目的名称 +具体定义类的含义;
4. 包的声明: package 包的名称
5. 包的使用: 如果使用不同包下面的类需要进行导包
   导包语法: import 需要使用的类.具体的包名
   如果需要使用这个包下所有的类 可以会用 * 来进行导包,导入所有,但是在开发中不建议使用 '‘号,因为开发过程中不会用到所有的包,若加上’'程序加载会变慢;

java中四大访问修饰权限

1. public > protected > 默认修饰符 > private 从大到小的顺序进行排列
   

快速生成一个实例类bean

1. 创建私有属性
2. set / get 方法(shift+alt+s快捷键)
3. 构造方法(shift+alt+s快捷键)
   注:快捷键是eclipse ideal快捷键为shift+insert

多态

1. 多态:一个事物或对象有多种形态;
2. 多态定义:
3. 多态的前提条件
   必须是有继承关系
   方法的重写
   父类的对象引用,执行子类队象的引用
4. 多态的语法: 父类 对象名 = new 子类();

在多态中成员变量的访问规则

1. 直接访问 : 对象名.属性; 父类 对象名 = new 子类() 看等号左边,等号左边是谁优先拿谁,如果父类没有这个属性,则往上进行查找一直找到object,若还找不道就报错;
   编译看左边,运行看左边.=>在多态获取中获取成员变量看父类是否存在这个变量,若果不存在向上查找,找不到就报错
2. 间接访问 : 通过方法调用访问;
   没有方法重写:谁调用这个方法就从哪个类去查找成员变量;
   有方法重写:获取的是子类的重写后的成员变量;

多态中访问方法

1. 没有方法重写时只能调用父类的方法;
2. 有重写时调用的方法为子类重写的方法;
   编译看左边,运行看右边.

多态中的向上转型

1. 向上转型的语法: 父类 父类对象名 = new 子类();

多态中的向下转型

1. 还原成本身的对象;

多态的好处

1. 以父类作为参数,减少重复代码;
2. 有利于后期代码的维护与扩展;
3. 有多态之后只需要关注右边实例化的对象,不用再去关注左边的对象;

多态的两种体现形式:

1. 以父类作为参数;
2. 以父类座位返回值;