面向对象
要设计一个计算机程序,一种方法就是根据问题的解决步骤,将程序组织为一系列的线性代码或函数,然后一次调用,即面向过程程序设计,如C语言程序设计。面向对象程序设计语言则是从另一个角度看待计算机程序,其核心是引入了对象的概念,从而可以模拟现实世界中的任何事物,与人类的思维习惯一致。当需求单一,或者简单时,我们一步一步去操作没问题,并且效率也挺高。可随着需求的更改,功能的增多,发现需要面对每一个步骤很麻烦了,这时就开始思索,能不能把这些步骤和功能在进行封装,封装时根据不同的功能,进行不同的封装,功能类似的封装在一起。这样结构就清晰了很多。用的时候,找到对应的类就可以了。这就是面向对象的思想。
面向对象的思想特征:1)面向对象更符合我们的生活中的行为思想习惯
2)面向对象将我们从执行者变成了指挥者,指挥对象做事情
3)面向对象简单性体现在这里:让我们事情从复杂性--->简单化
举个通俗的例子,就拿做饭来讲,
面向过程:自己去买菜--->洗菜--->切菜--->炒菜--->吃菜
面向对象:找个女朋友并教会自己的女朋做饭(买菜--->洗菜--->切菜--->炒菜),之后让女朋友为你做饭--->吃菜。
如果这辈子只吃一两次饭的话,显然面向过程会比较简单,可是呢?女朋友将相当于Java里的类,需要的时候光调用该类中的成员变量和方法就行了。面向过程是基于面向过程的语言。
面向对象的特征:封装、继承、多态;
一、类
类是一种具有相关属性和行为的集合,Java中类是种复合数据类型,是组成Java程序的基本元素,它封装了一类对象的属性(成员变量)和改变这些属性的方法。与简单数据类型的使用不同,用户必须先定义类,并生成该类的对象,然户通过对象去访问成员变量和方法。定义类:
类通过关键字class进行标识,格式如下:[类修饰符] class 类名 [extends 父类名] [implements 接口名]
{
...// 类体,包括定义类的成员变量和方法
}
定义成员变量:
成员变量的定义格式:[修饰符] 数据类型 成员变量名;
*成员变量的类型可以是任意的数据类型,在一个类中,成员变量名是唯一的。类成员变量在所有方法体之外,因此它的作用域是整个类。类中的所有方法均可直接访问成员变量。
成员变量和局部变量的区别
1)在类中位置不同
成员变量:类中,方法外
局部变量:方法声明上,或者再方法定义中
2)在内存中的位置不同:
成员变量:堆内存
局部变量:栈内存
3)生命周期不同:
成员变量:成员变量是随着类的加载而加载,随着类的消失而消失
局部变量:随着方法的调用而存在,随着方法调用完毕而消失
4)初始化值不同
成员变量:初始化由系统默认初始化,对于成员变量,可以不给初始化值,由系统给,然后显示初始化;
局部变量:定义一个局部变量,必须进行初始化,如果不初始化,无法使用(在使用之前进行初始化)
定义成员方法:
成员方法的定义格式:[修饰符] 返回值类型 方法名([参数列表])
{
方法体
}
*返回值类型可以是任意的数据类型,如果方法不返回任何值,则声明为void(空)。方法体则用来描述对象的行为。(关于方法的详细介绍在Java基础总结中return语句下有详细讲解)
//定义一个学生类,其中含有的属性为:学号,姓名,班级;学生的行为(方法):学习,玩游戏;
public class Student {
public int sid;//成员变量:学号
public String name;//姓名
public String grade;//班级
public void study() {
System.out.println("学生在学习");//成员方:法学习
}
public void play() {
System.out.println("学生在玩游戏");//玩游戏
}
}
二、对象
我们可以吧很多有属性有特点的东西看作成对象,因为根据属性或特点可以将这些东西归为一类。比如 把汽车看成一个类,大众就是一个对象,宝马也是一个对象,还有奔驰,奥迪......。它们都具有共同的属性,如价格,颜色,发动机排量,轴距......
创建对象:
声明:声明一个对象,包括对象名称和对象类型。实例化:使用关键字new来创建一个对象。(类名 对象明=new 类名(参数))
初始化:使用new创建对象时,会调用构造方法初始化对象。
class Student {
public int sid;//成员变量:学号
public String name;//姓名
public String grade;//班级
public char sex;//性别
public void study() {
System.out.println("学生在学习");//成员方:法学习
}
public void play() {
System.out.println("学生在玩游戏");//玩游戏
}
}
public class Studentdemo {
public static void main(String[] args) {
Student st1=new Student();//实例化对象
st1.name="常新玉";//赋值
st1.sid=050227;
st1.grade="五年级二班";
st1.sex='女';
}
}
使用对象:
格式:对象名.成员变量名
对象名.成员方法名
class Student {
public int sid;//成员变量:学号
public String name;//姓名
public String grade;//班级
public char sex;//性别
public void study() {
System.out.println("学生在学习");//成员方:法学习
}
public void play() {
System.out.println("学生在玩游戏");//玩游戏
}
}
public class Studentdemo {
public static void main(String[] args) {
Student st1=new Student();//实例化对象
st1.name="常新玉";//赋值
st1.sid=050227;
st1.grade="五年级二班";
st1.sex='女';
System.out.println(st1.name+" "+st1.sid+" "+st1.sex+" "+st1.grade);
st1.play();
st1.study();
}
}
显示:
常新玉 20631 女 五年级二班
学生在玩游戏
学生在学习
匿名对象:
匿名对象就是创建对象时没有对象名格式:new 类名();
package org.classdemo.text2;
class Student1{
String name;
int id;
int age;
public void show() {
System.out.println("匿名对象;"+name);
}
public void meet(Student1 s1) {//参数为引用Student1类的对象
System.out.println(s1.age+"岁");
}
}
public class Noname {
public static void main(String[] args) {
Student1 s=new Student1();//创建一个名为s的对象
s.name="李铭";//进行赋值
s.show();//使用所创建的对象s调用类中的方法
s.age=7;
s.meet(s);
System.out.println("----------------------------");
new Student1();//创建匿名对象
new Student1().name="李铭";//进行赋值
new Student1().show();//当使用匿名对象调用方法时相当于从新创建了一个匿名对象,所以匿名对象不要多次使用
new Student1().age=7;
new Student1().meet(new Student1());//匿名对象可以作为参数值传递
}
}
匿名对象;李铭
7岁
----------------------------
匿名对象;null
0岁
匿名对象的优势在于不需要创建一个有名对象,从而掉用类中成员方法,或成员变量。
构造方法:
当一个对象被创建时候,构造方法用来初始化该对象。构造方法和它所在类的名字相同,但构造方法没有返回值。 通常会使用构造方法给一个类的实例变量赋初值,或者执行其它必要的步骤来创建一个完整的对象。 不管你与否自定义构造方法,所有的类都有构造方法,因为Java自动提供了一个默认无参构造方法,它把所有成员初始化。 一旦你定义了自己的构造方法,默认构造方法就会失效。构造方法注意点:
1)方法名和类名相同
2)构造方法,连void都没有
class Student {
public int sid;//成员变量:学号
public String name;//姓名
public String grade;//班级
public char sex;//性别
Student(int sid,String name,String grade,char sex){
this.grade=grade;//用构造方法对成员变量初始化
this.name=name;//this:代表是当前类对象,或者是(当前类对象的引用),解决局部隐藏了成员变量
this.sid=sid;
this.sex=sex;
}
public void study() {
System.out.println("学生在学习");//成员方:法学习
}
public void play() {
System.out.println("学生在玩游戏");//玩游戏
}
}
public class Studentdemo {
public static void main(String[] args) {
Student st1=new Student(050227,"常新玉","五年级二班",'女');
System.out.println(st1.name+" "+st1.sid+" "+st1.sex+" "+st1.grade);
st1.play();
st1.study();
}
}
显示:
常新玉 20631 女 五年级二班
学生在玩游戏
学生在学习
构造方法是可以重载的。
class Student{
private String name ;
private int age ;
//无参构造
public Student() {
System.out.println("学生类的无参构造..");
}
//有参构造
public Student(String name) {
this.name = name;
System.out.println("带一个String类型参数的有参构造");
}
public Student(int age) {
this.age =age ;
System.out.println("带一个int类型参数的有参构造");
}
//带两个参数
public Student(String name,int age) {
this.name =name ;
this.age = age ;
System.out.println("带两个参数的有参构造...");
}
}
//测试类
public class Studentdemo {
public static void main(String[] args) {
//创建学生类对象
Student y = new Student() ;
Student t = new Student("高成") ;
Student t1= new Student(20) ;
Student t2 = new Student("高成", 20) ;
}
}
显示:
学生类的无参构造..
带一个String类型参数的有参构造
带一个int类型参数的有参构造
带两个参数的有参构造...
修饰符
publicpublic可以同时修饰类和成员变量,成员方法。如果public修饰一个类名,如public classA{...},则表示该类可以被所有的其他类访问或引用,
即其他类中可以创建该类的实例,访问该类的所有可见成员变量,调用可见方法。
如果类成员(变量和方法)用public修饰,表示该类的成员不仅可以被其内部成员访问,而且可以被其他类直接访问,外界可直接存取公有数据和公有方法。
private
private主要用于修饰类成员,表示该类成员只能被自身访问任何其他类(包括该类的子类)都无权访问和引用。将不希望他人随意引用或修改的数据和方法设置为private,这将使得私有成员对其他类不可见
,只有通过声明为public的方法才可以对数据进行访问,从而达到信息隐藏和封装的目的。
我们可以通过【SetXXX()/GetXXX()方法:公共访问方法】来访问被private修饰的类成员。
class Student{
//成员变量
private String name ;
private int age ;
private int sId;
private char sex ;
提供setXXX/getXXX()方法 快捷键:alt+shift+s+r
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getsId() {
return sId;
}
public void setsId(int sId) {
this.sId = sId;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}
//学习
public void study() {
System.out.println("学生爱Java...");
}
//打游戏
public void playGame() {
System.out.println("学生玩游戏..");
}
}
class Studentdemo{
public static void main(String[] args) {
Student t=new Student();
t.setName("王鑫");
t.setAge(15);
t.setSex('男');
t.setsId(132014);
System.out.println(t.getName()+" "+t.getAge()+" "+t.getSex()+" "+t.getsId());
}
}
显示:
王鑫 15 男 132014
static
关于static关键字:
1)静态随着类的加载而加载
2)static优先于对象存在
如:main public static void main(..){...}
3)static共享数据,可以被多个对象进行共享
举例: 饮水机(staticd的:共享的)
水杯(不能共享的...)
4)由于静态变量和静态方法都属于整个类,因此可以通过类名直接访问,而无须船舰该类的实例,格式如下:
类名.静态变量名;
类名.静态方法名([实参列表])
static用法:
一个类中可有静态变量,也可以有非静态
可以有静态成员方法,也可以有非静态的成员方法
静态的方法只能访问静态变量,或者是静态的方法
非静态的方法,既可以访问静态变量也可以非静态的变量...
简单记:静态只能访问静态
class Phone{
static String brand;
static String color;
static int price;
public String size;
public static void call() {
System.out.println("用手机打电话");
}
public void testphone(String size,String color) {//非静态可以访问静态的成员变量和方法
System.out.println(color+"的"+size+"手机");
call();
}
}
public class Phonedemo {
public static void main(String[] args) {
Phone.brand="iphone";
Phone.color="土豪金";
Phone.price=6888;
Phone.call();
System.out.println(Phone.color+" "+Phone.brand+" "+Phone.price);
Phone p=new Phone();
p.testphone("plus", "红色");
}
}
显示:
用手机打电话
土豪金 iphone 6888
红色的plus手机
用手机打电话