Java面向对象基础
来源:互联网 发布:室内温度测量软件 编辑:程序博客网 时间:2024/05/16 11:40
面向对象编程基础
1、类与对象
java语言是面向对象的
计算机语言的发展由面向机器向面向对象发展的,是越来越符合人的思维习惯的。
符合人类思维习惯程度
低 → 高
面向机器
汇编语言
面向过程
C语言
面向对象
Java语言
类和对象的关系
类是对象抽象出来的概念性的通用性的东西。
实例和对象的关系
(对象就是实例,实例就是对象)java最大的特点就是面向对象。
//定义类public class Test{public static void main(String []args){//创建一个猫对象Cat cat1=new Cat();//Cat是定义的一个数据类型//Cat cat1;//cat1=new Cat();// 等同于 Cat cat1=new Cat();//访问属性的 对象名.属性名字cat1.age=3;cat1.name="小白";cat1.color="白色";//创建第二只猫Cat cat2=new Cat();cat2.age=100;cat2.name="小花";cat2.color="花色"; }}class Cat{//下面的就是类的成员变量/属性int agr;String name;String color;}
类和对象的区别和联系
1、类是抽象的,概念的,代表一类事物,比如人类,动物类..
2、对象是具体的,实际的,代表一个具体事物,比如人类的对象“张三”..
3、类是对象的模板,对象是类的一个具体实例
类--如何定义类
一个全面的类定义比较复杂,如下:
package 包名;class 类名 extends 父类 implements 接口名{ 成员变量; 构造方法;成员方法;}
类--类的成员变量
成员变量是类的一个组成部分,一般是基本数据类型,也可是引用类型。
对象--如何创建对象
创建一个对象有两种方法
1、先声明再创建
1、对象声明:类名 对象名
2、对象创建:对象名=new 类名()
如下:
Cat cat;cat = new Cat();
2、声明创建一起
类名 对象名=new 类名()
如下:
Cat cat = new Cat();
对象--如何访问(使用)对象的成员变量
对象名.变量名; //先这样理解,以后加下访问控制符此表达就不准确了。
如下:
cat.name = “小花”;
***对象总是存在内存中的(具体应该在系统分配给JVM的堆区)
类--类的成员方法定义
成员方法也叫成员函数。
public 返回数据类型 方法名(参数列表){语句;//方法(函数)主体}
1、参数列表:表示成员方法的输入参数
2、返回数据类型:表示成员方法的输出
3、方法主体:表示实现某一功能的代码块
定义名字的规范写法:(PS:很多类型在之后的内容中会展示,这里做个总结)
类型
命名规范
关键字
举例
类名
首字母大写
class
MyClass
变量和方法
(除第一个单词外)首字母大写
int,byte,String等等
cat,myCat
包名
全小写
package
com.animal
常量
全大写(用下划线隔开)
final
PI,MY_CONST
除了上述驼峰法标准写法之外,还可以用下滑线法,如 my_class,my_cat
//方法名在有不同参数的情况下可以使用同一个方法名,即有参数和没参数的方法可以同名class Person{ //请注意类名首写字母应为大写如Person为类名 int age;String name;//1、可以输出我是好人方法public void speak(){ //请注意方法名的首写字母应为小写如speak为方法名System.out.println("我是一个好人");}//2、可以计算1+..+1000的方法public void jiSuan(){int result=0;for(int i=1;i<=1000;i++){result=result+i;}System.out.println("1+..+1000结果是"+result);}//3、带参数的成员方法,可以输入n值并计算1+..+npublic void jiSuan(int n){int result=0;for(int i=1;i<=n;i++){result+=i;}System.out.println("1+..+n结果是"+result);}//4、计算两个数的和public void add(int num1,int num2){int result=0;//与下面一句等同于return num1+num2;result=num1+num2;System.out.println("num1+num2="+result);}//5、计算两个数的和,并将结果返回给主调(调用它的)方法//注意:返回类型和返回结果的类型要一致//注意:在调用某个成员方法的时候,给出的具体数值的个数//和类型要相匹配。public int add2(int num1,int num2){return num1+num2;}//6、计算两个float数的和,并将结果返给主调方法public float add3(int num1,float num2,float num3){return num1+num2+num3;}}
类的成员方法--声明
public int test(int a);/*方法声明*/
这句话的作用是声明该方法,声明的格式为:
访问修饰符 数据类型 方法名(参数列表);
在给Person类添加add方法的例子中,关键字return的功能是把表达式的值返回的值返回给主调方法。
return 表达式;
类的成员方法(函数)--特别说明
1、方法的参数列表可以是多个
参数列表可以是多个,并且数据类型可以是任意的类型int float double char..
访问修饰符 返回数据类型 方法名(参数列表){语句; //方法主体}
2、方法可以没有返回值
返回类型可以是任意的数据类型(int,float,double,char..)也可以没有返回值void表示没有返回值
访问修饰符 返回数据类型 方法名(形参列表){语句; //方法主体}
2、构造方法(函数)
类的构造方法介绍
构造方法是类的一种特殊的方法,它的主要作用是完成对新对象的初始化。它有几个特点:
1、方法名和类名相同
2、没有返回值
3、在创建一个类的新对象时,系统会自动的调用该类的构造方法完成对新对象的初始化。
特别说明:
一个类可以定义多个不同的构造方法。
//定义一个人类class Person{int age;String name;//自定义默认构造方法public Person(){}//构造方法的主要用处是:初始化你的成员属性(变量)//自定义带参数构造方法public Person(int age,String name){age=age;name=name;}//构造方法2public Person(String name){name=name;}}
类的默认构造方法
如果没有定义构造方法,系统会自动生成一个默认构造方法。当创建Person对象时Person per1=new Person();默认的构造方法就会被自动调用。
类的构造方法小结:
1、构造方法名和类名相同;
2、构造方法没有返回值;
3、主要作用是完成对新对象的初始化;
4、在创建新对象时,系统自动的调用该类的构造方法;
5、一个类可以有多个构造方法;
6、每个类都有一个默认的构造方法。
3、this关键字
this是属于一个对象,不属于类的。java虚拟机会给每个对象分配this,代表当前对象。
注意事项:this不能在类定义的外部使用,只能在类定义的方法中使用。
/*this的必要性*/public class Test{public static void main(String []args){Dog dog1=new Dog(2,"大黄");Person p1=new Person(dog1,23,"张三");Person p2=new Person(dog1,24,"李四");p1.showInfo();p1.dog.showInfo();}}//定义一个人类class Person{//成员变量int age;String name;Dog dog;//引用类型public Person(Dog dog,int age,String name){//可读性不好//age=age;//name=name;this.age=age; //this.age指this代词指定是成员变量agethis.name=name; //this.name指this代词指定是成员变量namethis.dog=dog;}//显示人名字public void showInfo(){System.out.println("人名是:"+this.name);}}class Dog{int age;String name;public Dog(int age,String name){this.age=age;this.name=name;}//显示狗名public void showInfo(){System.out.println("狗名叫"+this.name);}}
4、类变量、类方法
类变量
类变量是该类的所有对象共享的变量,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它时,修改的也是同一个变量。
定义类变量:
访问修饰符 static 数据类型 变量名;
例如Person类中的
public static int num;
访问类变量:
类名.类变量名 或者 对象名.类变量名
例如
Person.num;
或者
Person person = new Person();person.num;
类方法
类方法是属于所有对象实例的,其形式如下:
访问修饰符 static 数据返回类型 方法名(){}
注意:类方法中不能访问非静态变量(类变量)。
使用:类名.类方法名 或者 对象名.类方法名
*重点*static静态的方法可以访问static静态变量(类变量),不能访问非静态变量,非静态方法可以访问非静态变量同时也可以访问static静态变量(类变量)。
public class Test{public static void main(String []args){//创建学生对象Stu stu1=new Stu(29,"aa",340);Stu stu2=new Stu(29,"aa",240);System.out.println(Stu.getTotalFee());}}//学生类class Stu{int age;String name;int fee;static int totalFee;public Stu(int age,String name,int fee){this.age=age;this.name=name;totalFee+=fee;}//返回总学费[这是一个类方法(静态方法)]//java中规则:类变量原则上用类方法去访问或操作public static int getTotalFee(){return totalFee;}}
类变量小结
1、当某一属性是所有对象所公有(共用)的情况用类变量
2、类变量与实例变量区别:
加上static称为类变量或静态变量,否则称为实例变量
类变量是与类相关的,公共的属性
实例变量属于每个对象个体的属性
类变量可以通过 [类名.类变量名] 直接访问
类方法小结
1、当某一方法只使用或不使用静态变量(类变量)的情况用类方法
类方法属于与类相关的,公共的方法
实例方法属于每个对象个体的方法
类方法可以通过 [类名.类方法名] 直接访问
5、java面向对象编程的四大特征(抽象/封装/继承/多态)
抽象
把一类事物的共有的属性和行为提取出来,形成一个模型(模版)。这种研究问题的方法称为抽象。
封装
封装就是把抽象出来的数据和对数据的操作封装在一起,数据被保护在内部,程序的其它部分只有通过被授权的操作(成员方法),才能对数据进行操作。
封装--访问控制修饰符
java提供四种访问控制修饰符号控制方法和变量的访问权限:
1、公开级别:用public修饰,对外公开
2、受保护级别:用protected修饰,对子类和同一个包中的类公开
3、默认级别:没有修饰符号,向同一个包的类公开
4、私有级别:用private修饰,只有类本身可以访问,不对外公开
4种访问级别的访问范围
访问级别
访问控制修饰符
同类
同包
子类
不同包
公 开
public
√
√
√
√
受保护
protected
√
√
√
╳
默 认
没有修饰符
√
√
╳
╳
私 有
private
√
╳
╳
╳
包--必要性
包--三大作用
1、区分相同名字的类
2、当类很多时,可以很好的管理类
3、控制访问范围
包--导包命令
package com.自定义名字;
注意:导包命令一般放在文件开始处。
包--命名规范
小写字母 比如 com.test
包--常用的包
一个包下,包含很多的类,java中常用的包有:
包名
作用
java.lang包
默认导入,提供了Java语言进行程序设计的基础类。
java.util包
提供了包含集合框架、日期和时间等各种实用工具类。
java.io包
通过文件系统、数据流和序列化提供系统的输入与输出
java.net包
提供实现网络应用与开发的类。
java.sql包
提供了使用Java语言访问并处理存储在数据库中的数据API。
java.awt包
提供了创建界面和绘制图形图像的所有类。
javax.swing包
提供了一组“轻量级”的组件。
java.text包
提供了与自然语言无关的方式来处理文本、日期、数字和消息的类和接口。
上表中的这些包,除了第一个包是自动导入外,其余的包都需要使用import语句导入,才可使用其包里面的类与接口。
包--如何引入包
语法:import 包;
比如import java.awt.*;
引入一个包的主要目的要使用该包下的类。
继承
继承--基础知识
继承可以解决代码复用,让编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时,可以从这些类中抽象出父类,在父类中定义这些相同的属性和方法,所有的子类不需要重新定义这些属性和方法,只需要通过extends语句来声明继承父类:
语法:class 子类 extends 父类
这样,子类就会自动拥有父类定义的某些属性和方法。
继承--深入讨论
1、
父类
子类
public 属性
继承
protected 属性
无修饰符属性
public 方法
protected 方法
无修饰符方法
private 属性
不继承
private 方法
2、结论
从表可以看出,父类的public修饰符的属性和方法;protected修饰符的属性和方法;默认修饰符属性和方法被子类继承了,父类的private修饰符的属性和方法不能被子类继承。
继承--注意事项
1、子类最多只能继承一个父类(指直接继承)
2、java所有类都是Object类的子类 (所有的子类都可以逐级继承,例:爷->父->子->孙)
多态
方法重载(overload)和方法覆盖(override)
在实现多态前,必须先弄明白方法重载(overload)和方法覆盖(override)。
方法重载(overload)
方法重载就是类的同一种功能的多种实现方式,到底采用哪种方式,取决于调用者给出的参数。
注意事项:
1、方法名相同
2、方法的参数类型,个数,顺序至少有一项不同
3、方法返回类型可以不同(只是返回类型不一样,不能构成重载)
4、方法的修饰符可以不同(只是控制访问修饰符不同,不能构成重载)
//方法重载(overload)getMaxpublic class Test{public static void main(String []args){MyMath mymath=new MyMath();System.out.println(mymath.getMax(12,14));System.out.println(mymath.getMax(24f,20f));}}class MyMath2{//返回较大的整数public int getMax(int i,int j){if(i>j){return i;}else{return j; }}public float getMax(float a,float b){if(a>b){return a;}else{return b; }}}
方法覆盖(override)
方法覆盖就是子类有一个方法,和父类的某个方法的名称、返回类型、参数一样,这就是子类的这个方法覆盖了父类的那个方法。
注意事项:
方法覆盖有如下条件:
1、子类的方法的返回类型,参数,方法名称,要和父类的返回类型,参数,方法名称完全一样,否则编译出错。
2、子类方法不能缩小父类方法的访问权限。
//子类方法覆盖父类方法public class Test{public static void main(String []args){//创建一只猫Cat cat1=new Cat();cat1.cry();Dog dog1=new Dog();dog1.cry();}}//动物类class Animal{int age;String name;//都会叫public void cry(){System.out.println("Animal not cry");}}//猫类class Cat extends Animal{//覆盖父类方法public void cry(){System.out.println("Cat cry");}}//狗类class Dog extends Animal{//覆盖父类方法public void cry(){System.out.println("Dog cry");}}
多态--概念
多态是指一个引用(类型)在不同情况下的多种状态。也可以理解成:多态是指通过指向父类的指针,来调用在不同子类中实现的方法。
实现多态有两种方式:1、继承;2、接口
public class Test{public static void main(String[] args) {//多态Animal an=new Cat();an.cry();an=new Dog();an.cry();}}//动物类class Animal{String name;int age;//动物会叫public void cry(){System.out.println("Animal not cry");}}//创建Dog子类并继承Animal父类及覆盖cry方法class Dog extends Animal{//狗叫public void cry(){System.out.println("Dog cry");}}class Cat extends Animal{//猫自己叫public void cry(){System.out.println("Cat cry");}}
多态--注意事项:
1、java允许父类的引用变量引用它的子类的实例(对象)
Animal an=new Cat();//这种转换时自动完成的
2、如果需要访问子类中父类没有的数据,需要强制转换为子类
Animal an=new Cat();//这种转换时自动完成的Cat cat = (Cat)an;//这是需要手动设置的
多态--补充
继承是多态得以实现的基础。从字面上理解,多态就是一种对象引用(类型)表现出多种状态。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定,分前期绑定和后期绑定两种。下面解释一下它们的定义:
1、前期绑定:在程序运行之前进行绑定,由编译器和连接程序实现,又叫做静态绑定。比如static方法和final方法,注意,这里也包括private方法,因为它是隐式final的。
2、后期绑定:在运行时根据对象的类型进行绑定,由方法调用机制实现,因此又叫做动态绑定,或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。
多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的偶合关系,使程序更容易扩展。
6、抽象类
当类的一些方法不能确定时,可以用abstract关键字来修饰该方法[抽象方法],用abstract来修饰该类[抽象类]。
public class Test {public static void main(String[] args) {//Animal an=new Animal();抽象类不允许实例化Animal an=new Cat();an.cry();an=new Dog();an.cry();}}//抽象类abstract关键词abstract class Animal{String name;int age;//动物会叫,使用了abstract抽象方法abstract public void cry();//抽象类中可以没有abstract抽象方法//抽象类内可以有实现方法public void sx(){System.out.println("实现方法");}}//当一个子类继承的父类是abstract抽象类的话,需要把抽象类的抽象方法全部实现。class Cat extends Animal{//实现父类的crypublic void cry(){System.out.println("Cat cry");}}class Dog extends Animal{//实现父类的crypublic void cry(){System.out.println("Dog cry");}}
抽象类--深入讨论
1、用abstract关键字来修饰一个类时,这个类就是抽象类。
2、用abstract关键字来修饰一个方法时,这个方法就是抽象方法。
3、abstract抽象类中的abstract抽象方法是不允许在抽象类中实现的,一旦实现就不是抽象方法和抽象类了。abstract抽象方法只能在子类中实现。
4、抽象类中可以拥有实现方法。
抽象类--注意事项
1、抽象类不能被实例化
2、抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract抽象方法。
3、一旦类包含了abstract抽象方法,则这个类必须声明为abstract抽象类。
4、抽象方法不能有主体。
正确的抽象方法例:abstract void abc();
错误的抽象方法例:abstract void abc(){}
7、接口
接口就是给出一些没有内容的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。
接口建立语法:
interface 接口名{方法;}
接口实现语法:
class 类名 implements 接口{方法;变量;}
小结:
接口是更加抽象的抽象的类,抽象类里的方法可以有方法体,接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。
接口--注意事项
1、接口不能被实例化
2、接口中所有的方法都不能有主体。错误语法例:void aaa(){},接口可以看作更加抽象的抽象类。
3、一个类可以实现多个接口
4、接口中可以有变量[但变量不能用private和protected修饰]
a、接口中的变量,本质上都是static的而且是final类型的,不管你加不加static修饰
b、在java开发中,经常把常用的变量,定义在接口中,作为全局变量使用
访问形式:接口名.变量名
5、一个接口不能继承其它的类,但是可以继承别的接口,而且可以多继承
6、当一个类实现了一个接口,要求该类把这个接口的所有方法全部实现
//USB接口interface Usb{public void start();public void stop();}class Camera implements Usb{public void start(){System.out.println("我是相机,开始工作了..");}public void stop(){System.out.println("我是相机,停止工作了..");}}//编写了一个手机,并实现了usb接口class Phone implements Usb{public void start(){System.out.println("我是手机,开始工作了..");}public void stop(){System.out.println("我是手机,停止工作了..");}}//计算机class Computer{//开始使用usb接口public void useUsb(Usb usb){usb.start();usb.stop();}}public class Test{public static void main(String[] args) {//创建 ComputerComputer computer=new Computer();//创建CameraCamera camera1=new Camera();//创建PhonePhone phone1=new Phone();computer.useUsb(camera1);computer.useUsb(phone1);}}
实现接口VS继承类
java的继承是单继承,也就是一个类最多只能有一个父类,这种单继承的机制可保证类的纯洁性,比C++中的多继承机制简洁。但是不可否认,对子类功能的扩展有一定影响。
所以:
1、实现接口可以看作是对继承的一种补充。(继承是层级式的,不太灵活。修改某个类就会打破继承的平衡,而接口就没有这样的麻烦,因为它只针对实现接口的类才起作用)
2、实现接口可在不打破继承关系的前提下,对某个类功能扩展,非常灵活。
8、final关键字
final基本概念
1、final中文意思:最后的,最终的。
2、final可以修饰变量或者方法。
3、被final修饰的变量其数据就不能改变了,就成为了常量(const)。
在某些情况下,可能有以下需求:
1、当不希望父类的某个方法被子类覆盖(override)时,可以用final关键字修饰。
2、当不希望类的某个变量的值被修改,可以用final修饰。如果一个变量是final,则必须赋初值,否则编译出错。
3、当不希望类被继承时,可以用final修饰。
//final方法的使用public class Test{public static void main(String[] args) {Aaa aaa=new Aaa();aaa.show();Bbb bbb=new Bbb();bbb.show();}}class Aaa{ //如果a不赋初值,a是0。定义类型后应赋值int a=0;//圆周率不让修改//带有final修饰的变量命名时应有_下划线来区分表示并且单词应该是全大写。//需要强制不被修改的数据一定要用final锁定final float REATE_1=3.1415926f;//使用final定义变量时一定要赋初值否则报错。//final int b; //b=1;final public void sendMes(){//给成员方法用final来修饰则表示不可以被修改,不可被覆盖。System.out.println("发送消息");}public void show(){System.out.println("a="+a);}}final class Bbb extends Aaa{//定义类前加final表示该类不允许被继承public Bbb(){a++;//不可以被修改//REATE_1+=1;}/*不能被覆盖public void sendMes(){System.out.println("发送消息")}*/}
final--注意事项
1、final修饰的变量又叫常量,一般用XX_XX_XX(大写)来命名。(带下划线)
2、final修饰的变量在定义时,必须赋值,并且以后不能再赋值。
final--什么时候用
1、类的某个方法不允许修改。
2、类不想被其它的类继承。
3、某些变量值是固定不变的,比如圆周率3.1415926
9、补充
初始化代码块与静态初始化代码块
public class Test{static int i=1;static{//该静态初始块只被执行一次i++;System.out.println("执行一次");}public Test(){ System.out.println("执行二次");i++;}{//该初始块每次创建对象被执行一次i++;System.out.println("执行二次");}public static void main(String []args){Test t1=new Test(); System.out.println(t1.i);Test t2=new Test();System.out.println(t2.i);}}
结论:
1、静态代码块只会在类加载进内存时,被执行一次。
2、代码块会在每次创建对象被执行一次。
3、代码块的访问顺序是从上至下,依次访问。
----------参考《韩顺平.循序渐进学.java.从入门到精通》
----------参考《JDK_API_1_6_zh_CN》
Java学习笔记--导航http://blog.csdn.net/q547550831/article/details/49819641
- java基础 面向对象
- Java面向对象基础
- java基础-面向对象
- java面向对象基础
- JAVA面向对象基础
- Java面向对象基础
- Java面向对象基础
- java基础----面向对象
- java 面向对象基础
- 【Java基础】面向对象
- java基础面向对象
- JAVA面向对象基础
- Java基础:面向对象
- java基础---面向对象
- Java基础--面向对象
- Java基础:面向对象
- Java基础--面向对象
- java基础--面向对象
- ARM+Linux系统启动流程分析----ARM处理器的启动流程
- JAVA学习_00
- win7中如何解决“该项不适用于在指定状态下使用”
- Junit使用教程(二)
- (转)C语言函数sscanf()的用法
- Java面向对象基础
- jstl中empty
- phpexcel基本属性及应用
- Selenium WebDriver Demo
- ARM+Linux系统启动流程分析----bootloader初始化系统
- PHP实现快排
- Android应用设置系统情景模式
- 文章标题
- [Object-C]判断字符串中是否包含表情