java_学习笔记01

day01继承&抽象类

第一章 匿名对象

匿名对象：只创建对象,但是不用变量接收
正常: Dog d = new Dog();   匿名: new Dog();
匿名的特点:只能使用一次,每次使用匿名对象时,实际都是创建了一个新的对象
		 匿名对象也可以作为方法的参数和返回值

第二章 继承

继承：在Java中，类的继承是指在一个现有类的基础上去构建一个新的类，构建	  出来的新类被称作子类，现有类被称作父 类，子类会自动拥有父类所有可      继承的属性和方法。

2.1 格式

public class 父类{
		....
	}
public class 子类 extends 父类{
		只要继承父类,那么子类就可以拥有并直接使用,父类中所有非私有的成员私有也可以使用,只是不能直接调用,可以间接使用
	}

2.2 继承的好处

a.提高代码的复用性
b.为多态提供了前提

2.3 继承后的特点——成员变量**********

a.如果子父类的成员变量名不同,那么写哪个成员变量就是访问哪个成员变量
b.如果子父类的成员变量名相同,那么根据就近原则,优先访问子类的成员变量

2.4 继承后的特点——成员方法**********

a.如果子父类的成员方法名不同,那么写哪个成员方法,就调用哪个成员方法
b.如果子父类的成员方法名相同,那么根据就近原则,优先调用子类的成员方法

2.5 重写的应用************************

在实际开发中,我们不会定义子父类重名的成员变量的
但是在实际开发中,我们肯定会定义和父类重名的成员方法

2.51方法的重载与重写

方法的重载:在同一个类中,方法名一样,参数列表不一样
方法的重写:在子父类中,子类中的方法和父类中的方法,除了方法体其他一模一样,子类中的该方法我们称为重写的方法	

---

当子类继承父类后,发现父类某些方法功能比较low时,那么子类需要重写该方法

如果重写方法中某些功能父类已经存在,只要使用super.方法名()调用父类的方法即可

2.6 注意事项

重写也叫覆盖,也叫覆写,英文名叫override

a.子类方法的权限 >= 父类方法的权限
				public protected default private
b.重写时,除了权限和方法体,其他必须一模一样
c.私有方法不能被重写

2.7 继承后的特点——构造方法

构造方法是不能被子类继承的!!!
在子类的任意构造方法的第一行,有这么一句代码,super(),代表调用父类的无参构造

2.8 super和this

父类空间优先于子类对象产生(内存图)
this  表示整个子类对象
super 表示子类对象中父类的空间

2.9 this和super可以访问构造方法

this(参数):调用本类的构造方法
super(参数);调用父类的构造方法	

2.10 继承的特点*****

a.Java只支持单继承,不支持多继承(一个子类只能有一个父类)
b.Java支持多层继承(子类只能有一个父类,父类也可以有自己的父类)	c.Java中有一个类,它是所有类的直接或者间接的父类,称为根类(Object类)

第三章 抽象类

​ 3.1 抽象类的概述

抽象方法: 只有方法的声明(头部),没有方法实现(方法体)
抽象类: 只要该类含有抽象方法,那么该类一定是一个抽象类

​ 3.2 abstract使用格式

抽象方法 public abstract 返回值类型 方法名(参数列表);
抽象类 
public abstract class 类名{
		}

抽象类的使用
	a.抽象类不能创建对象!!!!!
	b.抽象类天生就是做父类用的
	c.子类继承抽象类后,需要重写所有的抽象方法后,子类才能创建对象,否		则子类还是一个抽象类

3.3 注意事项

  抽象类不能创建对象
	抽象是有构造的,而是给子类调用的
	抽象类可以有抽象方法,也可以没有抽象方法
	抽象类的子类,必须重写抽象父类中所有的抽象方法

day02_接口&多态

一. 接口

接口是方法的集合

1.1 接口中的各种方法

a.抽象方法(jdk1.7)
b.默认方法和静态方法（jdk1.8）
c.私有方法（jdk1.9）

1.2 格式

public interface 接口名{
  //接口中只能定义方法
  //1.抽象方法
  public abstract void abs1();
  2.默认方法（default）
    public default void show(){
    ....
  }
  3.静态方法（static）
    public static void show2{ 
  }
}

1.3 接口的使用–实现

a.接口不能创建对象（接口中没有构造方法）
b.接口也是天生做父类的，让实现类实现它

1.4 接口中各种方法的使用

a.接口中的所有抽象方法，实现类必须重写
b.接口中的默认方法 实现类可以选择性重写
c.静态方法没有继承的概念

1.5 接口的多实现

一个类可以实现多个接口
a.实现类必须重写所有抽象方法（如果接口中方法重名，只需重写一次）
b.实现类可以选择重写接口中所有默认方法
	如果某个接口中默认方法相同，那么实现类中必须重写一次
c.静态方法没有重写，也不需要重写，因为静态方法通过接口名去直接调用
public class 类名 implements 接口1，接口2{}

1.6 继承和实现的优先级问题

一个类可以继承一个父类同事实现多个接口（先写继承再写实现）
如果父类的正常方法和接口默认方法中方法重名时，子类可以不重写，默认使用父类的方法

1.7 了解接口的多继承

类和类之间，称为继承，单继承
类和接口之间称为实现，多实现
接口和接口之间称为继承，多继承

1.8 接口中其他成员的特点

接口中不能有普通的成员变量，可以有特殊的“成员变量”，我们称为常量
常量必须有三个修饰符修饰：public static final 数据类型 常量名= 值；
接口中没有构造方法
接口中没有静态代码块

1.9 instanceof 关键字

---

二 多态

1.什么是多态：一个对象的多种状态

2.多态的前提和体现

多态有两个前提
	a.必须有继承或者实现
	b.必须有方法的重写
	
多态的体现：
	父类类型的变量 指向了 子类类型的对象

3.多态的代码实现

直接多态
	Animal a = new Dog();
间接多态
	Dog d = new Dog();
	Aaimal a = d;
方法调用时的多态
method(new Dog());
public static void method(Animal a){}

4.多态调用时的特点

编译时看父类，运行时看子类

5.多态的好处

使用父类类型的变量可以接收任何一个子类对象
提高代码的灵活性（扩展性）

6.多态的弊端

多态只能调用父类共有的方法，不能调用字类特有的方法

7.多态弊端的解决方案–转型

向上转型：子类-->父类 Animal an = new Dog();
向下转型: 父类-->子类 Dog d = (Dog)an;
	当多态需要调用子父类共有方法是，不需要转型
	当多态需要调用子类特有方法是，需要向下转型，转成子类

8.转型是出现的问题

类型转换异常：ClassCastException
如实际上是狗类转换为猫类

9.instanceof 关键字

instanceof :是不是谁的对象
	用法： boolean b = 对象名 instanceof 类名
	Animal an = new Cat();
	if(an instanceof Dog){}

day03

一 final关键字

1.final关键字 ：最终的，不可变的

a.final修饰类：'太监类-----被final修饰的类不能被其他类继承'
b.final修饰'方法
		被final修饰的方法，子类可以继承但是不能重写
		
c.final修饰'局部变量（局部变量）''
		被final修饰的局部变量只能赋值一次
		
d.final修饰'引用类型的变量'
		被final修饰的局部变量（引用类型）只能赋值一次'地址'
  		final Dog dd = new Dog()；
  		dd = new Dog();//报错，因为企图修改dd中的地址
  		
  		Dog ddd = dd;
			ddd = new Dog();//不报错，因为ddd没有被final修饰
      
e.final修饰'成员变量'
		被final修饰的成员变量'只能赋值一次'
  	两种方式:a."定义时赋值	' b.定义时不赋值，在'构造方法中赋值'

二 static 关键字

1.static 的含义:

static叫静态关键字
能修饰的成员'成员变量和成员方法'
特点:a.'被static修饰的成员，不属于对象，属于整个类'
		b.'被static修饰的成员，通过类名就可以直接调用'

2.static 修饰成员变量

被static修饰的成员变量:'不属于对象，属于整个类'
该成员变量，不建议通过对象访问('也可以，强行写')，"建议直接类名访问"

3.static 修饰成员方法

a.该成员方法也不属于对象，属于类
b.该成员方法可以通过类名直接调用

4.总结 static 成员的用法

static可以修饰成员变量：类变量
可以通过 "对象名.静态变量名"
建议通过 "类名.静态成员变量名"

 static修饰成员方法:"类方法，静态方法"
 可以通过 "对象名.静态成员方法名()"
 建议通过 "类名.静态成员方法名()"
 总结:"静态成员优先于对象存在，在没有对象的情况下，也可以通过类名调用"

静态和非静态的访问问题
 	 a."静态 可以访问 静态"
   b."非静态 可以访问 非静态"
   c.静态 '不可以访问 非静态'（非静态在创建对象后才存在，而静态是														属于类的，没有对象也可以通过类访问）
   d."非静态 可以访问 静态"
  
  

5.静态代码块

----静态优先于对象存在----

由static修饰的代码块
格式 ：
		static{
			静态代码块...
		}
位置:类中方法外
特点:"当第一次使用该类(加载到内存时)，该类的静态代码块会自动执行(只		  执行一次)，而且静态代码块有限与构造方法执行的"
作用:用给类初始化的，比如，加载驱动，读取配置文件等...

三 权限修饰符

a.java的四种修饰符

权限从大到小依次为:
public(公共的)	protected（受保护的）default(默认的，空的,不写)    private(私有的) 

b.开发中用到的权限

i.成员变量，使用   private
ii.成员方法，使用  public
iii.构造方法，使用 public

四 内部类

1.什么是内部类

2.成员内部类

定义在外部类的类中方法外
特点：a."内部类中可以无条件的访问外部类中的任何成员"
  	 b.如何创建内部类对象
  	 外部类名.内部类名 对象名 = new 外部类().new 内部类();

3.扩展:局部内部类

定义在方法中，只能在局部使用

4.【重点】匿名内部类

是一种快速创建对象的语法
匿名内部类，可以帮助我们"快速创建一个类的子类对象或者一个接口的实现对象"

5.总结：匿名内部类的使用格式

"快速创建抽象类的子类对象"
		抽象类名 对象名 = new 抽象类名（）{
				重写抽象类中个的抽象方法
		}；
		
"快速创建接口的实现类对象"
		接口名 对象名 = new 借口名(){
				重写接口中的抽象方法
		};
	

五 引用类型使用总结

基本类型可以做的引用类型也可以做
引用类型作为方法的参数和返回值

day04_Object

一 Object类

1.Object介绍

包:java.lang
作用:所有类的根类(包括数组)它一共11个方法 

2.toString方法

public String toString();
作用：返回对象的字符串表示
			默认表示格式："包名.类名@地址值"
开发中会重写toString，返回的不是地址值，而是返回"对象的所有属性值"
自动生成toString的方法：alt+INS,选择需要的成员属性即可
"注意：我们直接使用输出语句输出对象名的时候，其实通过该对象调用了				其toString()方法"

3.equals方法

public boolean equals(Object obj);
	作用：判断其他某个对象是否与此对象"相等"。
	Object 中 equals 方法默认比较的的是"地址值！
	开发中：我们通常会重写equals，比较的不是地址值，而是两个对象的所有属性，只有所有属性都相等，两个对象才相等，才会返回true
	自动生成equals的方法：alt+INS,选择需要的成员属性即可

4.总结

==与equals的区别
a.基本类型 只有==，比较的是数值
b.引用类型
	对象1 == 对象2 比较就是地址
	对象.equals(对象2) "如果没有重写，比较的是地址"
										"如果重写，比较的是属性值"

二 时间日期类

1.Date类

包："java.util"
作用：类Date表示特定的瞬间，精确到毫秒
构造：
		public Date();"当前的系统时间"
  	public Date(long time);创建一个距离标准时间time毫秒后的时		间 "标准时间:1970-01-01 00:00:00"英国
  		 "标准时间:1970-01-01 08:00:00"(北京时间)
常用方法：
		public long getTime();获取Date对象的毫秒值
		public void setTime(long time);设置Date对象的毫秒值

2.DateFormat类

包：java.text
作用：格式化Date对象 把Date对象转化成我们喜欢的格式的字符串
构造：DateFormat是一个抽象类 我们使用的是它的子类
	"SimpleDateFormat"
	包：java.text
	构造方法：
					public SimpleDateFormat(String pattern);创建一个																		日期对象，指定格式化模式
	成员方法：				
					public String  format(Date date);将一个Date对象																						 转化成字符串
					publicDate parse(String time);将字符串解析为Date

SimpleDateFormat常用的格式规则为：

y	年
M	月
d	日
H	时
m	分
s	秒

3.Calendar

包：java.util
作用：代表某个瞬间，精确到毫秒
构造：Calendar是一个抽象类
a.获取方式:
					通过一个静态方法获取
					public static Calendar getInstance();获取一个													Calendar 的实例对象(默认语言是时区)
b.常用方法：
	1. public int get(int field);获取日历对象中某一个字段的值
			Calendar c = Calendar.getInstance();
	例： int year = c.get(Calendar.YEAR);
	2. public void set(field int value);修改某一个字段的值
	3. public void add(field int value);增加某一个字段的值;
	4. public Date getTime();将日历对象转为日期对象 

3.Math

包："java.lang"
作用：包含用于执行基本数学运算的方法
构造：Math类的构造私有化，不允许任何人创建对象
成员方法：都是静态方法

8个方法: "Math._"
	public static int abs(int a);获取绝对值的方法 
			int abs = Math.abs(1);
	public static int max(int a,int b);获取最大值
	public static int min(int a,int b);获取最小值
	public static int round(float a);获取四舍五入值
	public static double random(float a);获取随机小数
										范围[0.0,1.0) '即包含0.0不包含1.0'
	public static double ceil(double a);"向上取整"
	public static double floor(double a);"向下取整"
  public static double pow(double a,double b);"求次幂"

四 System类

包：java.lang
作用：包含一些有用的方法，而且不能创建对象
构造：System类构造私有化，不允许任何人创建对象
方法：两个静态方法
	1 arraycopy(源数组,开始下标,目标数组,开始下标,长度)；复制数组
	2 exit(int code);退出JVM
public static long currentTimeMillis();获取当前系统时间的毫秒值

​

五 包装类

包装类的介绍
	基本类型对应引用类型(基本数据类型的包装类)
			char ->Character int->Integer
Integerd 构造和静态方法
	

3.自动拆箱和装箱的介绍*****************

装箱：把基本类型 转成 对应的包装类型
拆箱：把包装类型 转成 对应的基本类型
JDK1.5之后基本类型和包装类之间的运算，可以当做基本类型计算

4.基本类型与字符串之间的转化

基本类型-->String
转换方式 
	方式一：直接在数字后加一个空字符串
	 int number = 100;
	 String s1 = number + "";
	方式二：通过String类静态方法valueOf()
		String s2 = String.valueOf(number); 
 
String-->基本类型
	转换方式 
		方式一：先将字符串数字转成Integer，再调用valueOf()方法. 
			String s = "100";
			Integer i = Integer.valueOf(s); 
			int x = i.intValue(); 
****方式二："通过Integer静态方法parseInt()进行转换 
			int y = Integer.parseInt(s); 

day05_异常&线程

一、异常

1.什么是异常

程序运行过程中出现的问题

2.异常的继承体系

Throwable：所有异常的根类
	|-Error				错误(硬件问题)
	|-Exception		异常(程序员问题)
  	|-编译时异常(CheckException)：Exception及
    											其子类("RuntimeException除外)
  				在编译时就提示异常，称为编译时异常
  	|-运行时异常(RuntimeException)：RuntimeException以及子类
  				在编译时不提示，运行时直接在控制台上打印异常信息

3.异常类中常用的三个方法

public void printStackTrace();"打印异常的详细信息"
													("异常的类型，原因，位置") '常用'
public String getMessage();获取异常的信息(只有异常的原因)
public StringtoString();获取异常的类型和异常描述信息('不用')

4.异常的分类

i.编译时异常
Exception及其子类("RuntimeException除外)  
              在编译时就提示异常，称为编译时异常
ii.运行时异常
RuntimeException以及子类
							在编译时不提示，运行时直接在控制台上打印异常信息 

二、异常处理

1.模拟JVM抛出异常(关键字 throw)

格式：throw newXxx异常();

2.Objects类中提供的非空判断方法

Objects 是工具类(所有方法都是静态的)
  Objects.requareNonNull(T obj){}

3.遇到异常的两种处理方式

1.throws声明抛出异常

  给方法做声明的，声明方法内可能抛出异常，要求该方法的调用者处理
	'格式'：
 	public static void 方法名()throws XxxException,YyyException{
 				方法体；//
 	}

2.try…catch捕获异常

就是捕获异常对象，异常对象就不会向上抛出了
格式：
		try{
				可能抛出异常的代码
		}catch(XxxException e){
					//打印异常信息
					e.printStackTrace();
		}
		其他代码块(不管有无异常都会执行)

4,[扩展1]catch代码块中三种常见的处理方式

1.直接打印异常(开发和测试阶段)
2.写到日志文件(上线阶段)
3.转换成运行时异常(数据库阶段使用)

5.[扩展]多个异常如何获取处理

public static void method01() throws XxException{
}
public static void method02() throws XxException{
}
public static void method03() throws XxException{
}

a.分别出理：一个try一个catch
public static void main(String[] args){
  try{
  	method01();
  }catch(XxxException xxx){
  			//处理
  }
  ...
}

b.一个try多个catch
try{
  	method01();
  	method02();
  	method03();
  }catch(XxxException xxx){
  			//处理
  }catch(YyyException yyy){
  			//处理
  }
  ...
    "假设XxxException extends YyyException"
    那么必须先捕获子类异常，再捕获父类异常

c.一次捕获一次处理 "开发中常用"
try{
  	method01();
  	method02();
  	method03();
  }catch(Exception xxx){
  	//此处必须是所有可能异常的共同父类
  }
.......

6.finally代码块

finally 必须要执行的代码
格式：
	try{
		可能出现异常的代码
	}catch(Exception e){
		处理异常的代码
	}finally{
    必须要执行的代码
    一般用于释放资源的代码
    释放资源：关闭流，关闭数据库连接，关闭网络连接
	}

7.异常的注意事项

a.运行时异常，便一阶段不需要抛出，也不需要try..catch
b.子类重写后方法的异常，必须是 父类方法异常的子集
c.如果父类的方法没有抛出异常，那么子类重写方法是必须不能抛出，只能捕获
d.多个catch时，前面的异常必须是子类，后面的异常是父类
e.finally可以加，当有资源需要释放是添加finally

三、 自定义异常

1.为什么要自定义异常
	因为JDK不能考虑到所有可能的问题
2.自定义异常的步骤
	a.自定义异常必须是XXXException(命名)
	b.自定义异常必须继承Exception或者RuntimeException
	c.自定义异常必须提供至少两个构造(无参，带有异常信息的)
	d.在适当的时候抛出自定义异常

四、多线程*************************************************************

1.并行和并发

并行:多个事件，在同一时刻同事发生
并发:多个事件，在同一时间段内同时发生(交替执行)

2.进程和线程

'进程:正在运行的程序
'线程:进程中的一个执行单元，完成某个功能的小模块
进程和线程的一些'区别'
	进程拥有独立的内存(独立的栈空间和独立的堆空间)
	线程拥有独立的栈和共享的堆
'线程调度'
	一个CPU(单核)，同一个时刻只能执行一句代码
什么是是线程调度：
	CPU在不同的线程之间进行快速的切换
'线程调度分类'
	a.分时调度：每个线程轮流执行一定时间
	b.抢占式调度：每个线程随机获取CPU的时间
	

3.创建新的线程的方式一*************************************************************

API :一种方法是将类声明为Thread的子类
 		该类应重写Thread类的run方法，接下来可以分配并启动该子类的实例
步骤：
		a.子类 继承Thread
		b.子类 重写run方法
		c.创建子类对象
		d.启动线程 调用对象的start方法