面向对象的基本概念
一. 类
1.什么是类:
答:类是一组对象的分类,在Java中可以看成类别的划分
2.类如何创建:
答:
public class 类名{
//属性:静态描述
//方法动态描述:
}
二. 对象
1.什么是对象:
答:对象是对类的具体表现,具体实现!
2.如何产生一个对象:
答:new
3.匿名对象:没有名字的对象,匿名对象其实就是定义对象的简写格式;
使用情况:1>当对象对方法仅调用一次时,可以使用匿名对象进行简写;
2>匿名对象可以作为实际参数进行参数传递;(形参会引用这个对象)
三. 属性
1.什么是属性:
答:对类的静态描述!
2.如何定义一个属性:
答:在类中声明一个变量就行!
3.如何在对象中使用属性:
答:对象名.属性名
四. 方法
1.什么是方法:
答:对类的动态描述!
2.如何定义一个方法:
作用域 返回类型 方法名(形式参数列表){
方法体;
}
1> 方法名:遵循变量命名规则,规范要求:动词,首字母小写,驼峰
2> 作用域:显示(可见)级别,绝大多数都是public
3> 返回类型:无返回(void),有返回(type)
4> 形式参数列表:这个方法被调用需要传递什么参数
4.如何调用方法
答:对象名.方法名(实际参数列表);
五:构造器(构造方法)
1.作用:初始化属性,在创建对象时一同执行;
2.语法:
作用域 类名 (形式参数列表){
}
3.分类:
1>隐式构造器:系统给每个类都创建一个无参的构造器;(数值类型默认值为0,boolean型默认值为false,其余值为null)
2>显式构造器:自定义的构造器,当程序员书写显示构造器时,隐式构造器消失;
无参数构造器;有参数构造器。
六:类和对象
1.类是对象的抽象,对象是类的具体实现;
2.类是一个概念性的东西,而对象是一个实体,实实在在存在的;
3.类有属性和方法去描述,对象也有属性和方法,区别在于:类看中的是声明,对象看中的实现(值)。
七:成员变量和局部变量
1.成员变量:就是在类中定义的变量(属性),整个类中有效,成员变量存在于堆内存中的对象中,随着对象的创建而存在,随着对象的消失而消失;
2.局部变量:在方法,块,程序体中定义的变量,局部变量存在于栈内存中的方法中,局部变量随着所属区域的执行而存在,随着所属区域的结束而释放;局部代码块的应用:可以定义局部变量的生命周期;
3.不同点:成员变量是在new是初始化,局部变量是在使用前初始化(没有赋值的局部变量是不可以使用的);两者定义范围不同,作用域也不同,成员变量都有初始化值,局部变量没有初始化值;
4.优先级:当成员变量和局部变量重名时,以局部变量为主,如果要使用成员变量:this(当前类的对象)。
八:汇总
1.调用问题:
1>自身类中的方法(成员方法)或者方法(成员方法)时,可以直接调用也可以通过“this.名字”调用;
2>其他类中的方法(成员方法调)用别人类中属性(成员变量)和方法(成员方法)时,通过对象名调用;
2.站位
package Pro_0624;
public class Test {
public static void main(String[] args) {
//产生一个学生对象
//类 对象名 =new 类(构造器);
//产生了一个学生类的一个对象,对象名:s1
Student s1=new Student();
s1.stuNo=1;//给s1对象的编号赋予1
s1.stuName="张三";
s1.stuAge=27;
s1.stuSex="女";
System.out.println(s1.stuNo);
System.out.println(s1.stuName);
System.out.println(s1.stuAge);
System.out.println(s1.stuSex);
s1.eat();
s1.sleep();
//在教室中任意找一个类声明,然后产生一个对象去表述它
Room s2=new Room();
s2.light="日光灯";
s2.number_light=5;
s2.volume=100.32f;
s2.windos="有四块玻璃";
s2.room();
}
}
package Pro_0624;
public class Room {
String windos;
String light;
int number_light;
float volume;
public void room() {
System.out.println(number_light);
System.out.println(windos);
System.out.println(light);
System.out.println(volume);
}
}
package Pro_0624;
//在一个java文件中,可以有多个类,但一个类只有一个public,这个public类必须和文件名相同
public class DemoA {
public static void main(String[] args) {
//实名对象
Student s1=new Student();
//匿名对象
new Student().sleep();
}
}
class DemoB{
}
class DemoC{
}
package Pro_0624;
public class MethodDemoA {
public void methodA() {
System.out.println("你好");
}
//这个方法必须在方法体最后一行,返回一个int类型的值
public int methodB() {
int a=18;
return a;
}
public static void main(String[] args) {
//方法的调用者
MethodDemoA mad=new MethodDemoA();//首先产生一个对象
int a=mad.methodB();//调用这个方法会得到int 类型的值
System.out.println(a);
}
}
package Pro_0624;
//创建一个类
public class Student {
//他是什么?属性:静态描述
int stuNo;
String stuName;
String stuSex;
int stuAge;
//属性越多,描述越清晰
//他能做什么?方法:动态描述
public void sleep(){
System.out.println(stuName+"准备睡觉");
}
public void study(){
System.out.println(stuName+"准备学习");
}
public void eat(){
System.out.println(stuName+"准备吃饭");
}
//方法越多,描述越清晰
}
面向对象:三个特性
一.封装
1.概念:将属性私有化,提供了公开的接口访问这些私有属性。
2.实现:
1>将属性私有化(private);
2>提供两个公开方法(负责获取内容:get,负责修改内容:set)访问私有属性;
3.注意及好处:
1>提升了代码的安全性,提示了代码的隐私性;
2>命名规范****:Java是一种区分字母的大小写(case-sensitive)的语言,下面为Java语言中命名规范。
<1>Package(包)的命名:Package的名字应该都是由一个小写单词组成,例如net.ebseries.modules;
<2>Class(类)的命名:Class的名字首字母大写,通常由多个单词合成一个类名,要求每个单词的首字母也要大写,例如:DataFile或InfoParser;
<3>变量的命名:变量的名字可大小写混用,但首字符应小写。词由大写字母分隔,限制用下划线,限制使用美元符($),因为这个字符对内部类有特殊的含义。如:inputFileSize;
<4> Interface(接口)的命名:与Class的命名类似;
<5>Static Final 变量(相当于常量)的命名Static Final 变量的名字应该都大写,并且指出完整含义,例如:final MAXUPLOADFILESIZE=1024;
<6>方法的命名方法名的第一个单词应该是动词,大小写可混用,但首字母应小写。在每个方法名内,大写字母将词分隔并限制使用下划线。参数的名字必须和变量的命名规范一致。使用有意义的参数命名,如果可能的话,使用和要赋值的字段一样的名字:setCounter(int size){ this.size = size; } ;
<7> 数组的命名:数组应该总是用下面的方式来命名:byte[] buffer;而不是:byte buffer[](习惯性问题而已);
总结:尽量使用完整的英文描述符、采用适用于相关领域的术语、采用大小写混合使名字可读、尽量少用缩写,但如果用了,要明智地使 用,且在整个工程中统一、避免使用长的名字(小于 15 个字母是个好主意)、避免使用类似的名字,或者仅仅是大小写不同的名字、避免使用下划线(除静态常除外);
示例:有一个图书信息:
图书的ISBN
图书的名字
总页数(1~1000)
作者
售价1~100
出版社
二.继承
1.概念:子类继承父类的一般特性(非私有),以及自身的属性;
2.实现:
1>书写父类:书写父类的属性和方法
2>书写子类,需要子类继承父类extends
语法:
public class 子类 extends 父类
子类可以继承非私有的属性和方法
子类中可以书写自己的属性和认为较好的方法,这些属性和方法跟父类没有任何关系
如果子类对父类的某些方法的实现不是很满意,可以重写方法内容(实现)——方法的重写
3.注意事项:
1>java是单继承效果,也就是说一个子类只能继承一个父类;
2> java中有一个类(object),他是所有类的直接或者间接父类,也叫做祖先类;
3>子类定义对象时,先调用父类的构造器。在子类未指明调用哪个构造器时默认调用父类的无参构造,如果没有定义(或被有参构造覆盖),则编译时会报错(故注意无参构造的定义)。
4>指定调用父类构造:super(实参);(实参对应形参列表) //且必须放在子类构造器的第一行。
三.多态
1.概念:一个事物具有多种形态的特征,多态也是面向对象核心思想,如果一个语言不支持多态,那它就不是面向对象语言,如果支持封装和继承那只是基于对象语言;
2.实现:
1>方法的重写:子类重写父类的实现过程,这是一个垂直层次关系;
2>方法的重载:在同一个类中具有多个形同名称的方法,但其参数列表不同,是一个水平关系;
3.注意:
1>重写和重载的区别:
重写是一个垂直关系,它是子类重写父类的方法,要求结构相同,实现过程不同;重载是一个水平结构,它们之间参数不同;
2>在形参声明过程中,一般会声明的范围比较大,原因是声明的范围比较大,就可以传递父类,也可以传递子类,通用性较强;
四:三个方法修饰符:
1.static 静态:
1>概念:静态的,代表被修饰的内容会被在类加载的时候,内存加载它;
2>区域:
<1>属性:如果修饰属性,这个属性就依附于类存在,也就是说,当类加载时,这个属性就被创建了,这时候,这个属性就叫做:静态(类)变量;其调用方法为:类名.静态对象 或者 对象名.静态对象;(成员变量与静态变量的区别:成员变量只有在对象的生命周期中才存在,而静态变量在类加载入内存时就存在)
<2>方法:如果修饰方法,这个方法就依附于类存在,也就是说,当类加载时,这个方法就被创建了,这时候,这个方法就叫做:静态(类)方法;
<3>块:在类中书写的一段程序体,它会在类被加载时,依次执行,并且只执行一次;不可被手动调用;
3>注意事项:
<1>静态的 不能直接调用 成员的(静态的 肯定比 成员加载(创建)的早,导致静态的 创建时成员的 还未创建);例如:
Demo{
int a; //成员的
static int c=0;
public static void b(){ //静态方法
System.out.println(a); //出错
----------------------------
Demo z = new Demo();
System.out.println(z.a); //不出错
}
}
<2>成员的可以直接调用静态的;
<3>块在执行的时候是有顺序的,只能执行在它之前定义的内容;
<4>静态的可以直接调用静态的(包括main方法);
四:四个访问修饰符:
访问权限 | 类 | 包 | 子类 | 其他包 | 备注 |
public | yes | yes | yes | yes | 对任何人都是可用的 |
protect | yes | yes | yes | no | 继承的类可以访问以及和private一样的 权限 |
default | yes | yes | no | no | |
private | yes | no | no | no |
修饰符:
final :
当其修饰一个属性时,必须赋值,因构造器是不会给其赋值。
修饰类:代表这个类是不能被继承的;是最终类
修饰属性:代表这个属性是不能被修改的;是最终属性;
修饰方法:代表这个方法不能被重写;是最终方法;
变量:值可以发生改变的量
常量:值不能发生改变的量 5 9 9.1 张三 男
常量的命名规则:全大写 名词
public static final String USER_NAME = "李四";
abstract:抽象的
修饰方法和类;
修饰方法:方法只有定义没有实现,和final关键字冲突;
修饰类:当一个类中有一个方法被abstract修饰时,这个类也要被abstract修饰;这个类是抽象类;(当类中没有抽象函数时也可以用abstract修饰)
方法的定义:
抽象类不能被new
如果一个子类继承了一个抽象类,就要实现所有的抽象方法,否则这个子类也被定义成抽象类;
interface:接口
Java:单一继承;
通过接口:实现多继承;
接口的声明语法格式如下:
[可见度] interface 接口名称 [extends 其他的类名] {
// 声明变量
// 抽象方法
}
接口特性:
1.接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)在定义方法时abstract可以加上,也可以省略,但实质都是抽象的;
2.接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量(并且只能是 public,用 private 修饰会报编译错误),实质上它是一个常量,故必须赋初值(一般来讲常量都喜欢定义在接口中);
3.接口中的方法是不能在接口中实现的,只能由实现接口的类来实现接口中的方法;
4.接口也可以继承其他接口,继承原则同类;
5.接口不能被new,接口中没有构造器;
例如:pc卡槽:声卡,网卡……
接口的实现:
当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中,Implements关键字放在class声明后面。
实现一个接口的语法,可以使用这个公式:
[类的定义] implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...
一个类实现了多个接口时,这个类的对象属于各个接口的类型
声明对象时:等号右边
注意事项:
1.一个Java文件中只能有一个public类,且与文件名相同
2.Static,abstract,final:
Static可以和final同时使用,其他的都不能两两同时使用。
3.两种给属性赋值的方法:构造器,set函数。
4.如果定义对象时,声明的是父类,new的是子类,则可以调用的方法为父类中声明了的方法,但实现时用的是子类中的方法实现;