day01

一.java中的数据类型
基本数据类型
4类8种
整数
byte short int long
浮点数
float double
字符
char
布尔
boolean(true,false)
引用数据类型
Student s=new Student();
基本类型的数据转换
自动类型转换
byte,short char-->int-->long-->float-->double
由小到大
--------
byte =10;
int a=b;
--------
强制类型转换(有可能损失精度)
int a=10;
byte b=(byte)a;//有可能损失精度
二.运算符
算数运算符
++ / --
----------
int a=10;
int b=a++;(赋值的时候a++和++a是不一样的)
----------
比较运算符
比较运算的结果都是boolean类型
赋值运算符
+=
int a=10;
byte b=20;
//b=b+a;错误的
b+=a;//隐含了强制类型转换等于 b=(byte)(b+a)


逻辑运算符
连接boolean类型的表达式
&& 和 ||
注意&和&&的区别:
&&有断路的效果
三.方法
概述:类中的一段具有特定功能的程序,增强了代码的复用性和可维护性


public static 返回值类型(没有返回值用void) 方法名(参数){


}
调用方式:
1.有明确返回值类型:
赋值调用:
输出调用:
直接调用:
2.没有明确放回值得类型:
直接调用:
方法重载:在一个类中有多个重名的方法,1.方法名相同 2.参数列表不同 3.与返回值无关


三.数组
数组的特点:
元素类型必须一致
元素有整数索引
一旦定义好长度则无法改变
定义格式
动态:
元素类型[] 数组名=new 元素类型[length];
静态:
方式一:元素类型[] 数组名=new 元素类型[]{元素1,元素2....};
方式二:元素类型[] 数组名={元素1,元素2....};
四.学生Student类
成员变量
//姓名 private String name
//年龄 private int age;
//性别 private String sex
无参构造方法
有参构造方法
get,set方法


五.static关键字
static是一个关键字,用来修饰成员变量和成员方法
static的特点:
1.被所有的对象共享
2.可以直接使用类名来调用
3.静态所修饰的成员加载优先于对象
4.随着类的加载而加载
静态资源在方法区中
非静态的资源在堆内存中
静态与非静态
1) static生命周期
静态成员:随着类的加载而创建,随着程序的结束而销毁
非静态:随着对象的创建而创建,随着对象的销毁而销毁
2) 内存中的定义位置不同
静态成员:方法区中类字节码区域的静态区中
非静态:堆内存中
3)初始化实际不同
静态成员:类加载而加载
非静态:对象创建时初始化
static的注意事项:
1.静态只能调用静态
2.非静态的可以调用静态,也可以调用非静态的


静态的优缺点以及应用场景:
优点:
1.省内存,每个对象公用
2.使用方便,类名直接调用
缺点:
静态只能访问静态
举例,Math类
static方法
abs绝对值
ceil向上取整
floor向下取整
round 四舍五入
max 最大值
min 最小值
pow 几的几次方
random 随机数(0~1.0的小数)
六.自定义工具类
1.构造函数私有 private (目的不允许创建对象)
2.方法用static修饰  (方便类名直接调用)
七.代码块
{}就是代码块
1.局部代码块:存在于方法中,控制变量的生命周期(作用域)
2.构造代码块:提取构造方法中的共性,每创建一次对象就执行一次,并且在构造方法前执行
3.静态代码块:随着类的加载而加载,且只加载一次,加载类时需要的一些初始化操作,比如加载驱动

day02

一.继承:

1.多个类有共同的成员变量和成员方法, 抽取到一个另外的一个类中,

在让多个类去继承这个父类 ,我们的多个类就可以获取到父类的成员变量和成员方法了

2.使用 extends 关键字

3.格式:class 子类名 extends 父类名{  }

4.java中语言继承的特点

a.单一继承,只能继承一个父类(只能有一个亲爹)

b.不支持多继承:有些语言比如c++就可以继承多个父类

c.支持多层继承:就是  继承爸爸,还可以有个爷爷

d.子类只能获取父类的非私有成员( 非private)

5.就近原则

谁离我近就用谁

1)如果有局部变量就使用局部变量

2)如果没有局部变量,就使用子类的成员变量

3)如果没有局部,子类成员变量,就使用父类的成员变量

6.super:

可以获取父类的成员变量,成员方法,用法和this相似

7.继承中的成员方法的特点---重写 override

子类中没有这个方法,调用父类的

子类中重写了这个方法,调用子类的

方法的重写:在子父类当中(继承关系中),子类的方法和父类的完全一样,子类重写父类的方法(覆盖)

区分:方法的重载,在一个类中 多个重名的方法,参数列表不一致

8.方法重写的应用场景:当父类的方法不能完全满足子类使用,这个时候子类重写父类的方法,并可以在方法中使用关键字super调用父类的方法,这样既有父类的功能,也有子类的特有功能

9.方法重写的注意事项:

不能重写父类私有的方法

权限修饰不小于父类的

注解: @ Override

10.this()和super()执行顺序

特点:只能在构造方法的第一行出现

两者只能调用其中一个

子类方法中至少有一个去调用父类的构造方法

11.继承的优缺点

优点:1.提高了代码的复用性

2.提高了代码的可维护性

缺点:1.类的耦合性增强了

开发原则:高内聚,低耦合

二.匿名对象

没有变量引用的对象(没有名字的对象)

应用场景:

当方法只调用一次的时候可以使用匿名对象

注意:用匿名对象给属性赋值没有什么意义

三.final 关键字

final 修饰符,可以用于修饰类,方法,变量

final所修饰的类:不能被继承,不能有子类

final所修饰的方法:不能被重写

final所修饰的变量:不能改变,常量

常量:

字面值常量:1,2,3

自定义常量:被final所修饰的成员变量,一旦初始化不能被改变

注意:自定义常量必须初始化,可以选择显示初始化,或者构造初始化,或者使用静态代码块

命名规则:字母全部大写,不同单词用下划线"_"隔开

四.抽象类

abstract 抽象类:用于修饰方法和类

抽象方法:只有方法的声明,但是没有方法体的方法

抽象类:有抽象方法的类必须是抽象类

注意:一个类继承抽象类,需要重写所有的父类的抽象方法,抽象类则不用重写

抽象类的特点:

1.抽象方法只能在抽象类里面

2.抽象类和抽象方法必须用abstract来修饰

3.抽象类不能实例化

4.抽象类中可以有非抽象的方法

5.抽象类和类的关系也是继承

6.一个类继承抽象类,要么重写抽象类的所有抽象方法,要么他是一个抽象类

abstract和关键字final,private不可以共存

如果不想让一个类 实例化,可以用private和abstract来修饰

抽象的思想

Reader和Writer

起到了规范的作用

day03

一.接口 interface

1.接口是一个比抽象类还抽象的类,接口里全是抽象方法,接口和类时实现(implements)的关系

2.格式:  权限修饰符 interface 接口名 { }

3.作用:

a.为实现类扩展出接口具有的功能

b.弥补java只能单继承的局限性,抽象类只能单继承,而接口可以多实现

4.实现接口:

implements 关键字

格式 权限修饰符 class 类名 implements 接口1,接口2...{ }

5.注意:

1.所有方法都是抽象方法

2.接口不能创建对象

3.接口没有构造器

4.接口默认使用public和abstract修饰方法

5.只能使用public和abstract修饰

6.建议以后手动添加修饰符

7.接口中只有常量 (默认是pulbic static final修饰)

------------------------------------

public static final int NUM=10;        //正确

static final int NUM1=10;        //正确

final int NUM2=10;                //正确

int NUM3=10;                        //正确

-------------------------------------

public abstract void method();        //正确        

abstract void method();                //正确

void method();                        //正确

public static abstract void method();//错误

-------------------------------------

6.类与类的关系:继承,单一继承,多层继承

类与接口的关系:实现,多实现

接口与接口的关系:继承,可以多继承

提问:

1.继承只有都是单一继承,多层继承吗 答案:不是 接口可以多继承

2.抽象类的子类必须要实现所有的抽象方法吗 答案 不是  子类是抽象类可以不用

7.接口的优点

a.弥补java只能单继承的局限性,抽象类只能单继承,而接口可以多实现

b.对外提供规范(电脑usb接口)

c.降低了程序的耦合性(可以实现模块化开发,定义好规则,每个人实现自己的模块,提高开发效率)

8.接口和抽象类的区别

共性: 不断的抽取,抽取抽象的概念

区别:

1.与类的关系

类与接口是实现关系,而且是多实现,一个类可以实现多个接口

类与抽象类之间是继承关系,而且是单一继承,一个类只能有一个父类,可以多层继承

2. 成员

a)成员变量:

抽象类.可以有成员变量,也可以有常量

接口,只能有常量

b)成员方法:

抽象类,可以有抽象方法,也可以有非抽象方法

接口,全部是抽象方法

c)构造方法:

接口类,可以有构造方法

接口,无构造方法

9.什么时候使用接口 ,什么时候用抽象类

接口,扩展功能(猫学会了游泳) 游泳是接口

抽象类,共性抽取(猫是动物)  动物是抽象类

举例而已,别较真~

10.乒乓球,篮球运动员 案例 略.

二.多态

1.多态的前提:

a.字符类的继承关系,或者实现关系

b.方法的重写

c.父类的引用指向子类 //Animal a=new Dog();

动态绑定:运行期间调用的方法,是根据具体的类型

2.多态成员的特点

a.成员变量---编译看左边,运行看左边

b.静态方法---编译看左边,运行看左边

c.成员方法---编译看左边,运行看右边

3.向上转型,向下转型

子类型转换为父类型(向上)

父类型转子类型(向下)

引用类型之间的转换

--------------

Animal a=new Dog();//向上转型

Dog d=(Dog)a;//向下转型

---------------

基本数据类型的转换

由小到大 自动转型

byte,short,char-->int-->long-->float-->double

由大到小  强制转换

4.多态的优缺点

多态的优缺点:

优点:可以提高可维护性(多态前提所保证的),提高代码的可扩展性

缺点:无法直接访问子类特有的成员

5.扩展

a. instanceof 判断某个类是不是一个这个类的对象(返回值是boolean)

if(p instanceof Phone){

}

b.实现多个接口,和类不能有相同的属性和方法

day01

一.java中的数据类型
基本数据类型
4类8种
整数
byte short int long
浮点数
float double
字符
char
布尔
boolean(true,false)
引用数据类型
Student s=new Student();
基本类型的数据转换
自动类型转换
byte,short char-->int-->long-->float-->double
由小到大
--------
byte =10;
int a=b;
--------
强制类型转换(有可能损失精度)
int a=10;
byte b=(byte)a;//有可能损失精度
二.运算符
算数运算符
++ / --
----------
int a=10;
int b=a++;(赋值的时候a++和++a是不一样的)
----------
比较运算符
比较运算的结果都是boolean类型
赋值运算符
+=
int a=10;
byte b=20;
//b=b+a;错误的
b+=a;//隐含了强制类型转换等于 b=(byte)(b+a)


逻辑运算符
连接boolean类型的表达式
&& 和 ||
注意&和&&的区别:
&&有断路的效果
三.方法
概述:类中的一段具有特定功能的程序,增强了代码的复用性和可维护性


public static 返回值类型(没有返回值用void) 方法名(参数){


}
调用方式:
1.有明确返回值类型:
赋值调用:
输出调用:
直接调用:
2.没有明确放回值得类型:
直接调用:
方法重载:在一个类中有多个重名的方法,1.方法名相同 2.参数列表不同 3.与返回值无关


三.数组
数组的特点:
元素类型必须一致
元素有整数索引
一旦定义好长度则无法改变
定义格式
动态:
元素类型[] 数组名=new 元素类型[length];
静态:
方式一:元素类型[] 数组名=new 元素类型[]{元素1,元素2....};
方式二:元素类型[] 数组名={元素1,元素2....};
四.学生Student类
成员变量
//姓名 private String name
//年龄 private int age;
//性别 private String sex
无参构造方法
有参构造方法
get,set方法


五.static关键字
static是一个关键字,用来修饰成员变量和成员方法
static的特点:
1.被所有的对象共享
2.可以直接使用类名来调用
3.静态所修饰的成员加载优先于对象
4.随着类的加载而加载
静态资源在方法区中
非静态的资源在堆内存中
静态与非静态
1) static生命周期
静态成员:随着类的加载而创建,随着程序的结束而销毁
非静态:随着对象的创建而创建,随着对象的销毁而销毁
2) 内存中的定义位置不同
静态成员:方法区中类字节码区域的静态区中
非静态:堆内存中
3)初始化实际不同
静态成员:类加载而加载
非静态:对象创建时初始化
static的注意事项:
1.静态只能调用静态
2.非静态的可以调用静态,也可以调用非静态的


静态的优缺点以及应用场景:
优点:
1.省内存,每个对象公用
2.使用方便,类名直接调用
缺点:
静态只能访问静态
举例,Math类
static方法
abs绝对值
ceil向上取整
floor向下取整
round 四舍五入
max 最大值
min 最小值
pow 几的几次方
random 随机数(0~1.0的小数)
六.自定义工具类
1.构造函数私有 private (目的不允许创建对象)
2.方法用static修饰  (方便类名直接调用)
七.代码块
{}就是代码块
1.局部代码块:存在于方法中,控制变量的生命周期(作用域)
2.构造代码块:提取构造方法中的共性,每创建一次对象就执行一次,并且在构造方法前执行
3.静态代码块:随着类的加载而加载,且只加载一次,加载类时需要的一些初始化操作,比如加载驱动

day02

一.继承:

1.多个类有共同的成员变量和成员方法, 抽取到一个另外的一个类中,

在让多个类去继承这个父类 ,我们的多个类就可以获取到父类的成员变量和成员方法了

2.使用 extends 关键字

3.格式:class 子类名 extends 父类名{  }

4.java中语言继承的特点

a.单一继承,只能继承一个父类(只能有一个亲爹)

b.不支持多继承:有些语言比如c++就可以继承多个父类

c.支持多层继承:就是  继承爸爸,还可以有个爷爷

d.子类只能获取父类的非私有成员( 非private)

5.就近原则

谁离我近就用谁

1)如果有局部变量就使用局部变量

2)如果没有局部变量,就使用子类的成员变量

3)如果没有局部,子类成员变量,就使用父类的成员变量

6.super:

可以获取父类的成员变量,成员方法,用法和this相似

7.继承中的成员方法的特点---重写 override

子类中没有这个方法,调用父类的

子类中重写了这个方法,调用子类的

方法的重写:在子父类当中(继承关系中),子类的方法和父类的完全一样,子类重写父类的方法(覆盖)

区分:方法的重载,在一个类中 多个重名的方法,参数列表不一致

8.方法重写的应用场景:当父类的方法不能完全满足子类使用,这个时候子类重写父类的方法,并可以在方法中使用关键字super调用父类的方法,这样既有父类的功能,也有子类的特有功能

9.方法重写的注意事项:

不能重写父类私有的方法

权限修饰不小于父类的

注解: @ Override

10.this()和super()执行顺序

特点:只能在构造方法的第一行出现

两者只能调用其中一个

子类方法中至少有一个去调用父类的构造方法

11.继承的优缺点

优点:1.提高了代码的复用性

2.提高了代码的可维护性

缺点:1.类的耦合性增强了

开发原则:高内聚,低耦合

二.匿名对象

没有变量引用的对象(没有名字的对象)

应用场景:

当方法只调用一次的时候可以使用匿名对象

注意:用匿名对象给属性赋值没有什么意义

三.final 关键字

final 修饰符,可以用于修饰类,方法,变量

final所修饰的类:不能被继承,不能有子类

final所修饰的方法:不能被重写

final所修饰的变量:不能改变,常量

常量:

字面值常量:1,2,3

自定义常量:被final所修饰的成员变量,一旦初始化不能被改变

注意:自定义常量必须初始化,可以选择显示初始化,或者构造初始化,或者使用静态代码块

命名规则:字母全部大写,不同单词用下划线"_"隔开

四.抽象类

abstract 抽象类:用于修饰方法和类

抽象方法:只有方法的声明,但是没有方法体的方法

抽象类:有抽象方法的类必须是抽象类

注意:一个类继承抽象类,需要重写所有的父类的抽象方法,抽象类则不用重写

抽象类的特点:

1.抽象方法只能在抽象类里面

2.抽象类和抽象方法必须用abstract来修饰

3.抽象类不能实例化

4.抽象类中可以有非抽象的方法

5.抽象类和类的关系也是继承

6.一个类继承抽象类,要么重写抽象类的所有抽象方法,要么他是一个抽象类

abstract和关键字final,private不可以共存

如果不想让一个类 实例化,可以用private和abstract来修饰

抽象的思想

Reader和Writer

起到了规范的作用

day03

一.接口 interface

1.接口是一个比抽象类还抽象的类,接口里全是抽象方法,接口和类时实现(implements)的关系

2.格式:  权限修饰符 interface 接口名 { }

3.作用:

a.为实现类扩展出接口具有的功能

b.弥补java只能单继承的局限性,抽象类只能单继承,而接口可以多实现

4.实现接口:

implements 关键字

格式 权限修饰符 class 类名 implements 接口1,接口2...{ }

5.注意:

1.所有方法都是抽象方法

2.接口不能创建对象

3.接口没有构造器

4.接口默认使用public和abstract修饰方法

5.只能使用public和abstract修饰

6.建议以后手动添加修饰符

7.接口中只有常量 (默认是pulbic static final修饰)

------------------------------------

public static final int NUM=10;        //正确

static final int NUM1=10;        //正确

final int NUM2=10;                //正确

int NUM3=10;                        //正确

-------------------------------------

public abstract void method();        //正确        

abstract void method();                //正确

void method();                        //正确

public static abstract void method();//错误

-------------------------------------

6.类与类的关系:继承,单一继承,多层继承

类与接口的关系:实现,多实现

接口与接口的关系:继承,可以多继承

提问:

1.继承只有都是单一继承,多层继承吗 答案:不是 接口可以多继承

2.抽象类的子类必须要实现所有的抽象方法吗 答案 不是  子类是抽象类可以不用

7.接口的优点

a.弥补java只能单继承的局限性,抽象类只能单继承,而接口可以多实现

b.对外提供规范(电脑usb接口)

c.降低了程序的耦合性(可以实现模块化开发,定义好规则,每个人实现自己的模块,提高开发效率)

8.接口和抽象类的区别

共性: 不断的抽取,抽取抽象的概念

区别:

1.与类的关系

类与接口是实现关系,而且是多实现,一个类可以实现多个接口

类与抽象类之间是继承关系,而且是单一继承,一个类只能有一个父类,可以多层继承

2. 成员

a)成员变量:

抽象类.可以有成员变量,也可以有常量

接口,只能有常量

b)成员方法:

抽象类,可以有抽象方法,也可以有非抽象方法

接口,全部是抽象方法

c)构造方法:

接口类,可以有构造方法

接口,无构造方法

9.什么时候使用接口 ,什么时候用抽象类

接口,扩展功能(猫学会了游泳) 游泳是接口

抽象类,共性抽取(猫是动物)  动物是抽象类

举例而已,别较真~

10.乒乓球,篮球运动员 案例 略.

二.多态

1.多态的前提:

a.字符类的继承关系,或者实现关系

b.方法的重写

c.父类的引用指向子类 //Animal a=new Dog();

动态绑定:运行期间调用的方法,是根据具体的类型

2.多态成员的特点

a.成员变量---编译看左边,运行看左边

b.静态方法---编译看左边,运行看左边

c.成员方法---编译看左边,运行看右边

3.向上转型,向下转型

子类型转换为父类型(向上)

父类型转子类型(向下)

引用类型之间的转换

--------------

Animal a=new Dog();//向上转型

Dog d=(Dog)a;//向下转型

---------------

基本数据类型的转换

由小到大 自动转型

byte,short,char-->int-->long-->float-->double

由大到小  强制转换

4.多态的优缺点

多态的优缺点:

优点:可以提高可维护性(多态前提所保证的),提高代码的可扩展性

缺点:无法直接访问子类特有的成员

5.扩展

a. instanceof 判断某个类是不是一个这个类的对象(返回值是boolean)

if(p instanceof Phone){

}

b.实现多个接口,和类不能有相同的属性和方法