------- android培训、java培训、期待与您交流！ ----------
1.面向对象
类
class
-> 自定义一个类.
如何定义类.
class 类名{
成员变量(属性)
成员方法(行为)
}
类是模板,有了类可以根据类创建对象.
对象
堆内存中的一块实体空间.
存储了对象的属性.
new
-> 创建对象.
通过new 关键字创建对象. 在堆内存开辟了空间.存储了对象的属性.
类类型 对象名=new 类名();
虽然是通过new 操作符创建的对象, new 操作符返回一个结果,该结果是对象的引用(地址值),非对象本身.
对象的使用
-> 如何使用对象.
可以通过对象名. 的形式操作对象.
1. 对象名.属性名=值;
给对象的属性赋值.
2. 对象名.属性名
取出对象的属性
3. 对象名.成员方法
执行对象的特有的行为.
匿名对象
-> 存在的意义.
简化书写的方式.
1. 调用方法
如果调用成员方法时, 只需要使用一次,可以使用匿名对象.
new 类名().成员方法(); 虽然使用new 操作符创建了一个对象,并执行了该对象的方法,但是只要方法执行完毕该对象
立即变为了垃圾(来及回收是不定时回收的).
2. 作为方法的实际参数传递的.
public Car repairCar(Car car){
}
Car c=new Car();
repairCar(c);
***************
封装
解决的问题,程序出现了问题. 需要使用该种方式解决?
-> 封装的实现的方式.
成员变量私有,公有的get set 方法 这就是封装的一种实现方式...
-> 存在的意义.
如果使用封装, 在其他类中,可以直接通过对象名.属性名的方式直接访问对象的属性. 可以属性赋值.
出现非法的数据,对象保存了非法的数据,程序不够安全和健壮了...
如何有效的过滤非法数据.
1. 类的成员变量私有
其他类中, 无法通过对象名.属性名的方式直接访问该对象的属性类.
2. 该类提供公有的get 和set 方法.
可以在方法中加入逻辑判断,过滤非法的数据.
(只不过偷懒了... )
注意: private 实现方式仅仅是封装的一种体现...
方法(函数) 也是封装的一种体现...
一段独立功能的程序. 可以解决特定的问题,实现特定的目标...
Arrays.sort(数组);
dry 电脑...
主板, cpu ,内存,硬盘,电源... -> 跑了...
风险高-> 避免安全隐患. 将电脑封装到主机箱中...
不能封死,对外提供操作... 开机按钮,网卡口...
对外提供开机按钮,usb ,网卡开口...
-> 封装的好处:
隐藏了类的具体的实现(侧重隐私的).
成员变量私有的话,对外(其他类)隐藏改成员变量...
如果不提供get 和set 方法的话,在其他类中确实无法访问了...
提高了对象的数据(属性)的安全性
在set方法中,过滤了非法数据.
提高了程序的可维护性安全性.
提高了可维护性?
成员变量私有->无法直接通过对象. 属性的形式访问对象的属性了.
但是可以通过get 和set 方法访问...
可以根据实际需求决定是否要提供get 或者set .
如果需要对外提供属性->添加get 方法.
如果需要对象提供修改属性->添加set 方法...
员工:
工号
get
no set
工资:
no get
set
构造函数
作用
初始化对象.
使用
通过创建对象时, new 操作符后 添加具体的实际参数,jvm 根据实际参数匹配对应的构造函数...
构造函数在创建对象时,有jvm 根据实际的参数调用的,用于初始化对象的属性的.
一个类中可以存在多个构造函数,是以重载的形式存在.
重载: 函数名相同, 参数列表不同的.
构造函数的特点:
1. 函数名和类名相同
2.没有返回值
3. 没有返回值类型, 和void 不同.
4. 自定义类,如果没有提供构造函数,编译器提供一个无参数构造(默认),如果自定义了构造函数,默认的无参数构造就没有了
构造代码块
在一个类中直接以一对花括号存在{}
作用: 初始化对象
构造函数的不同:
只要创建对象就会执行,并且优先于构造函数执行. 在创建对象的整个周期内只执行一次.
构造函数,jvm 根据具体的实际参数确定对应的构造函数.
this
含义:
对象的引用.
使用场景
可以用在成员方法中
可以用在构造函数中.
作用
1.用在成员方法中,可以区分成员变量和局部变量同名的问题.
set 方法.
this.成员变量=局部变量. 局部变量的值赋值给了成员变量(属性)
注意:成员方法的依赖于对象. 需要通过对象名.成员方法的形式调用...
哪个对象调用该方法,方法内部的this 就是那个对象了.
2. 用在构造函数的第一行. 调用本类的其他构造函数.
this() -> 调用无参数构造.
this("jack",28); 调用有参数构造.参数一为String,参数二位int
注意的如果在一个构造函数中,调用本类的另一个构造函数,这个语句需要在第一行.
因为java 希望初始化的动作优先执行...
static
静态
修饰成员变量
使用场景,作用是什么
类变量, 不需要创建对象,可以直接通过类名来访问了.
静态变量随着类的加载初始化,存在于方法区(类的字节码文件.class 文件也存储在方法区)由于类只加载一次,静态变量只有1份.
如果对象和对象之间出现了共享的数据,可以使用静态变量.
实际开发:
public static final 数据类型 常量名=常量值;
静态和常量和公共一起出现.
公共的->访问权限最大.都可以直接通过类名访问.
static -> 静态的,只有1个.
final ->最终的,不能被改变的,常量
public static final dobule PI=3.14
Math.PI .
修饰成员方法
使用场景,作用是什么.
如果设计的方法,不想创建对象,就像调用的话,直接将方法设计为静态的...
什么时候考虑使用这样的方法呢?
设计工具类时, 例如Arrays Collections Maths 这些工具类...
为了方便的让大家使用导工具类中的方法,直接将所有方法设置为静态的,有了避免多余的创建对象,将工具类的构造函数私有化.
只能通过 类名.方法名访问了工具类中的方法了...
静态代码块
随着类的加载而执行,并只执行一次.
想要执行第二次或者第三次,重新启动程序... 所以在整个正序的运行周期内,只执行一次.
适合初始化类(程序)
例如: 静态代码块中连接库...
图书管理系统初始化书库...
*****************
类和类之间的关系
继承
extends
解决了什么问题,好处的什么.
如果类和类之间符合is a 的关系...
ia a
xxx 是 yyy 的一种(一类)
可以使用继承建立类和类之间的关系.
如果建立了继承关系,可以提高代码的复用性,减少重复代码...
1.描述类和类之间的关系,并减少了重复代码,提高代码的复用性.
注意:
不要为了减少重复代码就使用继承,要符合is a 关系.
super
使用场景
子类中.
1. 访问父类属性.
2. 访问父类的成员方法.
3. 访问父类的构造函数.
在子类的构造函数第一行有默认的语句super() ,创建子类对象时,先默认的调用父类的无参数构造.
当子类的构造函数中,自定义的调用类父类的构造函数时,默认的super() 就没有了...
注意: 如果在构造函数中,调用父类的构造函数是,不同同时出现this,调用本类的构造函数.
都是初始化的动作,都需要在第一行.
class fu{
private String name;
fu(){
}
fu(String name){
this.name=name;
}
public void setName(String name){
this.name=name;
}
public String getName(){
return name;
}
}
class zi extends fu{
zi(){
}
zi(String name){
super(name);
}
}
class sun extends zi{
sun(){
}
sun(String name){
super(name);
}
}
重写
override 覆盖.
存在的意义,java设计了重写的意义.
使用前提:
子父类中(实现类实现接口的实现类中),子类继承类父类的方法,如果父类的方法无法满足子类的需求,子类可以重写父类的方法. 增强子类的方法.
核心:
子类是比父类强的.
使用场景:
子类继承类父类,父类是抽象类,存在抽象方法.
子类如果调用该方法,必须重写...
实现类实现类接口,接口中有方法.
实现类实现类该接口,如果想要调用该方法,必须重写...
注意:
子类继承父类, 实现类实现接口中.
函数名要形同,参数类表一致,修饰符(子类>=父类),返回值类型(子类方法返回值类型<=父类方法的返回值类型)
Object 在java 是一个顶层的父类 比较大的.
Object 子类 就是小的.
class Animal{}
class Dog extends Animal{}
class Father{
Animal getAnimal(){
return new Animal();
}
}
class Son extends Father{
public Dog getAnimal(){
return new Dog();
}
}
Dog < Animal
重写只存在于非静态成员方法,和成员变量,静态方法没有关系的...
final
使用场景
1.修饰成员变量
普通的变量,可以取值和赋值. 如果不想修改变量的值. 可以将变量设置为常量.final修饰.
2.修饰成员方法
普通的成员方法(非私有的),子类继承并重写该方法, 如果父类不希望子类重写,可以将方法设置final.
3.修饰类
如果该类不希望有子类...
4.修饰形参.
避免形参随意的修改...
抽象类
abstract
抽象方法:
如果一个类中的成员方法,方法体不明确,无法确定,可以将方法设计为抽象方法,交给子类来实现(重写)
修饰符 abstract 返回值类型 函数名(参数列表);-> 没有方法体的方法,并使用abstract 声明了的就是抽象方法了...
抽象类:
如果一个类中存在一个以上的抽象方法,该类必须声明为抽象类...
修饰符 abstract class 类名{
}
使用场景
实际开发中,将符合is a 关系的类, 组成一个体系, 有所谓的顶层父类和底层的实现类.
将顶层的父类设计为抽象类,顶层的父类的方法的方法体是不确定(明确)抽象的...
注意事项
抽象类不能创建对象.
抽象类中存在抽象方法,功能是不完整,如果能够创建抽象类对象的,调用到抽象方法后,是没有任何意义.
抽象类可以有成员变量可以有构造函数,可以有非抽象方法
都是给子类使用的. 体现了继承的思想,提高代码的复用性...
抽象类当然可以没有抽象方法
目的仅仅是为了禁止创建对象.->如果是抽象类,即使使用反射技术,也无法创建出该类对象...
使用事项:
子类继承抽象类.
1. 子类要么重写父类中的所有的抽象方法,
子类继承的父类,如果父类还继承的有父类, 子类就需要重写全部的继承下的抽象方法...
2. 子类要么也声明为抽象类.
不需要重写抽象方法了,抽象类允许存在抽象方法.
接口
interface implements
语法:
interface 接口名{
public static final 属性;
public abstract 返回值类型 函数名();
}
使用事项:
1.类实现接口要么重写该接口中的所有方法...
2.类实现接口要么声明为抽象类.
3. 一个类可以同时实现多个接口.
3. 接口和接口之间是继承关系,一个接口可以继承多个接口.
思考题：
设计一个类．
表示古代的皇帝，
皇帝比较特殊，唯一的．．．
如果描述了皇帝类，该类在整个程序中只能创建一个对象． 只能有１个．．．
创建对象：
如何保证对象的唯一性
单例设计模式.
设计模式:
解决一类特定的问题时,发明了特定的代码适合解决该问题...
单例:
1. 构造函数私有.
禁止在其他类中创建该类对象.
2. 本类提供一个本类对象.
在成员变量的位置设置一个本类对象的成员变量,并初始化(创建本类对象).
3. 提供静态方法获取到这个本类对象.
*/
public class Demo1{
public static void main(String[] args){
for(int i=0;i<10;i++){
System.out.println(Emperor.getEmperor());
}
}
}
// 单例(单态)-> 保证该类对象的唯一性...
class Emperor{
// 本类类型的成员变量.
private static final Emperor em=new Emperor();
// 构造函数私有
private Emperor(){
}
// 公共静态方法获取到本类对象.
public static Emperor getEmperor(){
return em;
}
}