Java

笔记
初始面向对象编程
1)什么是面向对象编程(OOP)
相对于面向过程编程
面向过程编程方式代码冗余较多
维护和扩展成本高,不易开发大型程序
2)为什么需要面向对象编程
在中大型项目中,面向对象编程思维方式
能较大的改善代码冗余
提高程序的可维护性和可扩展性

类和对象
1)生活中的对象
对象就是东西
万物皆对象
对象是可操作,拥有数据数值的主体
2)生活中是先有对象,后有类型
类是概念,规定了这个类型的对象应该有的
基本信息

3)java中的类和对象
java中是先有类,后有对象
类中定义 1.属性
2.方法
真正使用属性和方法的是对象

4)使用类和对象处理问题的好处
减少代码冗余
提高程序的可维护性和可扩展性

使用java面向对象的思维处理简单问题
1)新建类(class)
类名的首字母大写
新建Emp类
类中定义属性和方法
2)实例化对象
<类名> <对象名>=new <类名>();
3)使用对象
使用对象名打.调用属性或方法
一个类可以实例化多个对象
对象的属性有默认值(0\0.0\false\null)

方法重载
1)什么是方法重载(方法超载,overload)
一个类中方法签名中方法名相同,
方法的参数列表不同的多个方法
方法签名:方法名+参数列表
类中不允许方法签名完全相同的多个方法
2)方法重载的注意事项
方法重载的必要条件
2.1)在同一个类中
2.2)方法名相同
2.3)参数列表不同
参数的(个数,类型,顺序)
2.4)访问修饰符(public)
与返回值类型无关

3)为什么要使用方法重载
方便同一个类中功能相似的方法
的记忆和调用

4)系统中的方法重载
系统中我们正在使用或使用过的
有很多方法重载后的内容
4.1)System.out.println();
4.2)Arrays.copyOf();
4.3)Arrays.sort();
4.4)还有很多,数不过来

5)我们学习方法重载,在哪使用
我们今后主要将方法重载技术
使用在类的构造方法中

构造方法
我们现在实例化对象后
需要为对象的属性依次赋值,太麻烦,
使用构造方法简化
1)什么是构造方法
就是在类进行实例化对象时运行的一个
特殊的方法
构造方法也叫构造器\构造函数
2)构造方法的作用
通常情况下,使用构造方法为属性赋初值
3)构造方法的编写方式(格式)
在类中:
public <类名>(){

}
1.构造方法没有返回值类型
2.构造方法方法名必须和类名相同
4)构造方法的注意事项
4.1)构造方法会在实例化对象时运行
new <类名>();
4.2)如果一个类没有编写构造方法
编译器在编译时会默认生成一个无参构造
4.3)如果一个类编写了构造方法
那么就不会生成默认的构造了
4.4)构造方法可以重载
4.5)构造方法不能使用对象调用

局部变量和成员变量
1)局部变量是声明在 方法 中的变量
成员变量是声明在 类 中的变量
2)局部变量只能在声明它的方法中使用
成员变量能在当前类中的任何方法使用
3)局部变量和成员变量重名时
局部变量具有更高的优先级
如果想输出成员变量的值
需要在变量前加 this.

this关键字
1)this关键字的使用
1.1)在方法中,类的属性前编写this.
调用当前对象的属性
能够将成员变量和局部变量区分
this.<属性名>;

this关键字
1)什么是this关键字
是对象在程序中对自身的引用
2)this的使用
2.1)this.属性
调用当前对象的属性
2.2)this.方法名()
调用当前对象的方法
2.3)this()
调用当前类构造
必须编写在当前类构造方法中的第一行

引用数据类型的数组
1)java中数据类型分两种
1基本数据类型
2引用数据类型

定义基本数据类型的数组
int[] nums=new int[5];
2)引用数据类型数组(String,自造类,数组)
<类型>[] 数组名=new <类型>[长度];
声明后
数组中的元素的默认值为null
为数组中的元素赋值
数组名[下标]=new <类名>(<参数列表>);
dogs[0]=new Dog("旺财",1,5,"雪纳瑞");
调用元素的方法
数组名[下标].属性\方法()
dogs[0].show();

引用数据类型声明的同时赋值
Dog[] dogs={new Dog(),new Dog(),....}

3)null和null指针
null表示当前这个引用
没有引用任何对象
所以不能对null进行任何操作

如果对null引用调用了任何属性或方法
那么就会发生
NullPointerException
空指针异常

4)多维数组(二维数组)
数组中的元素还是数组
声明
int[][] arr=new int[长度][];
arr[0]=new int[5];
arr[1]=new int[8];
....
声明的同时赋值
int[][] arr={
{7,6,5,1,4},
{2,6,4,7,8,6,1,4},
{1,9},
....
}

继承
面向对象编程的三(四)大特征
(抽象),封装,继承,多态
1)什么是继承
继承,是面向对象编程中一种代码复用的方式
2)为什么要使用继承
为了减少程序中的代码冗余
提高程序的可维护性和可扩展性
3)怎么样使用继承
格式
class <类名 A> extends <类名 B>{
}
类A继承了类B
类A中可以使用类B中的属性和方法
称类A为子类(派生类)
称类B为父类(超类\基类)
4)继承的注意事项
4.1)子类和父类应该符合is-a(是一个)关系
4.2)java中的继承是单根的
4.3)java中的继承是传递的

1.Object类
1)Object类是什么
Object类是java语言中,所有类的父类
2)自造类和Object的关系
如果自造类不继承任何类
那它会默认继承Object

2.继承下构造方法的执行顺序
1)实例化子类对象时
也会实例化父类对象
因为子类对象中包含着一个父类对象的引用
2)执行顺序:
先运行父类构造
再运行子类构造
3)默认运行
子类构造中,
如果没有指定调用父类的哪一个构造
那么默认调用父类的无参构造
可以使用super关键字来指定调用父类的构造

3.super关键字
1)什么是super
super是当前对象对父类对象的引用
2)怎么使用super
2.1)super.属性
调用当前类父类对象的属性
区分子类和父类的同名属性
2.2)super.方法名()
调用当前类父类对象的方法
区分子类和父类的同名方法
2.3)super()
调用当前类父类的构造方法
必须编写在当前类构造方法中的第一行

构造方法中的第一行
如果不写this()或super()
默认为super();
构造方法生成的快捷键
类中直接Alt+/选类名相同的方法 回车
Alt+Shift+S~O

4.向上造型(向上转型)
1)什么是向上造型
一个子类对象,当做父类类型使用
2)为什么需要向上造型
多个不同类型的子类对象
可以使用它们的父类类型的数组来保存
3)如何使用向上造型
格式
<父类类型> <引用>=<子类对象>;
子类对象赋给父类引用
父类引用指向子类对象
4)向上造型后的问题
父类引用指向子类对象
但是这个父类的引用只能调用到父类成员

5.方法重写(方法覆盖,override)
1)什么是方法重写
子类中重写编写父类中的方法
2)为什么需要方法重写
向上造型后,父类引用不能调用到子类的
成员,使用方法重写改善这个问题
当子类中对父类个某个方法的编写不满意时
就可以重写父类中的方法
3)怎么样使用方法重写
简单的方法重写
3.1)在子类中
3.2)编写一个和父类方法名相同
3.3)参数列表相同
3.4)返回值和访问修饰符也相同的方法
4)方法重写的作用
方法重写后
向上造型后的父类引用
调用子类重写后的方法时
实际运行的是子类重写后的方法
5)方法重写的详细规则
5.1)必须相同的
1方法名
2参数列表
5.2)可以不同的
1返回值类型
-如果父类方法的返回值类型
是void或基本数据类型
那么必须相同
-如果父类方法的返回值类型是引用类型
那么子类中重写的方法的返回值
可以是父类返回值类型的子类
2访问修饰符(明天讲)
-子类方法的访问修饰符不能比
父类更严格
3声明的异常(第二阶段讲)
-子类重写的方法声明的异常
可以是父类被重写方法声明异常的子类

方法重写和方法重载的区别
位置 方法名 参数 返回值 修饰符
重载 同类 相同 不同 无关 无关
重写 子类 相同 相同 相同* 相同*

 

 

1.包(package)
1)什么是包
java程序中存放同一个模块或单元
一些类的集合
2)为什么使用包
2.1)不同包中的类可以重名
2.2)方便团队开发
3)如何使用包
3.1)在类中可以通过包名访问不同包中的类
3.2)java中一个类是通过全类名来唯一标识的
全类名:包名+类名,中间用.分隔
3.3)java中的包名全部小写
如果需要分隔使用.即可
3.4)如何定义一个全球范围内唯一的全类名
:使用公司域名反写的方式
cn.tedu.shoot.game.Start

2.import关键字
1)什么是import
java程序中,在使用不同包中的类之前
对一个类进行导入的语法格式
2)为什么需要import
使用import导入包或类之后
在使用这个类时就不需要编写全类名了
3)如何使用import
3.1)导入类
import java.util.Scanner;
import oopday04.am.a.Dog;
3.2)导入包
import java.util.*;
import oopday03.am.a.*;
只能导入当前包中的所有类
不能导入子包中的类
3.3)导包的重名
java中不允许一个类中导入相同类名的
多个类
如果一定要使用,在代码中使用全类名即可
3.4)默认的导包
java程序中默认自动导入
java.lang.*;

3.访问修饰符
1)什么是访问修饰符
规定类中的成员的访问级别的关键字
规定了类中的属性和方法能被谁访问
不能被谁访问
2)为什么使用访问修饰符
能够增强程序的封装性,提高安全性
3)认识访问修饰符
public(公有)
protected(保护)
默认(友好)
private(私有)

4)访问级别
所有类
不同包的子类
同包类
当前类

当前类 同包 子类 其他类
public √ √ √ √ 宽松
protected √ √ √
默认 √ √
private √ 严格

5)使用注意事项
5.1)类中的成员可以被4种访问修饰符修饰
5.2)非类中成员的class只能被默认或public
修饰
5.3)一般情况下,类中的
属性私有,方法公有

6)属性的封装
Dog类中的属性
age为例
age属性过大或者负值都是不合理的
为了防止不合理的赋值,提高程序运行的安全性
我们将age属性设置为私有

编写公有的方法的getters和setters
为私有属性赋值或取值
在setter方法中添加条件,防止不合理赋值

4.final关键字
1)什么是final关键字
final关键字也是一个修饰符
能修饰
类\方法\属性\局部变量(参数)
final是最终的意思
2)final修饰类
final class XXX{}
含义为不允许这个类被继承

原因:如果程序要为了一个类中的某一个功能
而继承这个类的话,
会增加程序的架构的复杂度
3)final修饰方法
public final void xxx(){
}
将一个方法修饰为final
这个类的子类中不允许重写这个方法

也可以防止无意识的重写
4)修饰成员变量(属性)
private final int a=0;
被final修饰的属性的属性值不允许修改
被final修饰的属性在对象被实例化之前
必须被赋值
1.声明的同时赋值
2.构造方法中赋值
5)修饰局部变量
修饰方法中声明的局部变量
这个变量将只能被赋值一次
修饰方法的形式参数

6)final 修饰引用数据类型
这个引用的属性值可以变
但是引用不能变化

1.static关键字
1)static只能修饰类中的成员
成员变量 方法 初始化代码块
被static修饰的称之为"静态"
没有被修饰的普通成员也被称之为"实例成员"

2)static修饰成员变量
<访问修饰符> static <类型> 变量名;
private static int x;
如果一个成员变量的值需要共享给
该类型的所有对象,那么就使用静态
2.1)使用静态修饰成员变量会保存在方法区
方法区中的属性,每个类只能存一份
2.2)静态属性属于类,也叫类属性
官方建议使用类名调用
2.3)静态属性的好处是不会随实例化对象
生成多份,所以节省内存空间
2.4)使用时机:当该类中的所有对象共享
同一个数据或资源时

3)static修饰方法
<访问修饰符> static <返回值类型>
方法名(<参数>){
}
public static void abc(){
}
3.1)static修饰的方法称之为静态方法
也叫类方法
3.2)静态方法可以直接使用类名调用
3.3)静态方法可以不实例化对象,直接使用
3.4)静态方法属于类
这个方法中没有也不能使用this
不能访问这个类的实例成员
3.5)静态方法不能重写
3.6)如果这个类中某个方法和当前类对象
无关就可以声明成静态的

4)static修饰初始化块
初始化代码块
在类中编写{}
{}中的代码就是初始化代码块
在构造方法运行之前运行

4.1)使用static修饰初始化块
称为静态初始化代码块
无论实例化多少对象,只运行一次
而且是最先运行
4.2)静态块运行时机是在
JVM加载这个类时运行
所以运行时间早
又因为JVM不会重复加载一个类
所以只运行一次

2.final static 常量
public final static int DAY_OF_WEEK=7;
1)一个成员变量同时
被final和static关键字修饰,就被称为常量
2)常量就是在程序中不会被修改的一个数值
3)修饰后的效果
3.1)final:不允许修改
3.2)static:使用类名调用,且只有一个
3.3)一个成员变量同时被final和static
修饰,会产生一个额外效果
这个常量被使用时,在编译时就确定值
就是在运行时直接使用,提高运行效率

4)常量的命名规范
所有字母均大写
使用_来分割单词
5)常量一般情况下推荐声明的同时赋值
常量也可以在静态初始化块中赋值
但不推荐,因为效率低

 

1.抽象类
1)什么是抽象类
在java程序中不存在对象的类型
2)为什么需要抽象类
抽象类能够更加直接的为程序搭建结构
3)怎么样定义一个抽象类
使用abstract关键字修饰class即可
abstract class Aoo{
}
4)抽象类的特征
4.1)抽象类不能实例化
4.2)在抽象类中可以编写抽象方法
4.3)抽象方法数量不限(0~很多)

2.抽象方法
1)什么是抽象方法
就是在抽象类中不能写出具体操作的方法
2)怎么定义抽象方法
在方法的返回值前加abstract
public abstract void abc();
3)抽象方法特征
3.1)抽象方法不能编写方法体
3.2)抽象方法必须在子类中被重写
除非子类也是抽象类

3.抽象类和抽象方法
1)注意事项
1.1)abstract和final关键字
不能同时修饰类或方法
2)抽象类的意义
2.1)因为抽象类不能实例化
明确了抽象类只是程序框架
使程序结构更加清晰
2.2)抽象类除了不能实例化
拥有普通类的其他所有功能
所以特别适合作为父类提供
代码复用
2.3)更自然的使用向上造型
调用子类重写后的方法

1.内部类
1)什么是内部类
就是在一个类中,又编写了另一个类
我们将内部类称为inner 外部类称为outer

2)成员内部类
在类的成员位置,编写的内部类
称之为成员内部类
2.1)成员内部类可以
使用全部4种访问修饰符修饰
2.2)成员内部类中的方法
可以访问外部类中的私有成员
2.3)外部类可以在方法中实例化内部类对象
并访问内部类的私有成员
2.4)当外部类和内部类有重名成员时
内部类中调用外部类重名成员前加
<外部类名>.this.<外部类成员名>
Outer.this.n=10;
2.5)内部类要想在其他类中实例化
需要先导包到内部类
然后实例化对象
Inner inn=new Outer().new Inner();
2.6)所有内部类在编译之后
都会产生自己独立的class文件

3)匿名内部类
匿名内部类就是在类中
通过就地实现父类(接口)
而编写的一个没有名字的内部类
3.1)匿名内部类必须通过继承一个父类
或实现一个接口才能编写
3.2)匿名内部类通常编写在方法中
3.3)匿名内部类可以使用
外部类中的私有成员
并且成员重名时的处理方式和
成员内部类一致
3.4)特别需要注意:
匿名内部类的对象是向上造型后的
所以只能调用到继承的父类的可访问成员
3.5)匿名内部类的方法中
不能修改该内部类所在方法中
局部变量的值
3.6)匿名内部类的方法中
要获取该内部类所在方法中的局部变量
需要保证局部变量只能被赋值一次
3.7)jdk1.6之前
所有匿名内部类使用的局部变量
都必须使用final修饰

2.计时器
1)什么是计时器
一般用于设定每隔一段时间调用一次某个方法
的功能
2)计时器的目的
例如
每隔1秒中,在控制台上输出一个Hello
3)使用计时器的步骤
3.1)步骤1:
实例化一个计时器对象
3.2)步骤2:
使用匿名内部类继承TimerTask类
重写方法编写每隔一段时间要做的事情
3.3)步骤3:
使用计时器设置并周期性的运行
TimerTask

转载于:https://www.cnblogs.com/Lgongzi/p/11204880.html