目录
package six;
public class Dog {
private String gender;//性别
private String name;//姓名
private String color;
private String call;
public String getSex() {//获取性别的值
return gender;
}
public void setSex(String gender) {//修改性别的值
this.gender = gender;
}
public String getName() {//获取姓名
return name;
}
public void setName(String name) {//修改名字
this.name = name;
}
public String getColor() {//获取颜色
return color;
}
public void setColor(String color) {//修改颜色
this.color = color;
}
public String getCall() {//获取叫声
return call;
}
public void setCall(String call) {//修改叫声
this.call = call;
}
public String introduce() {//introduce自我介绍方法
return "性别 :"+gender+" 姓名 :"+name+" 颜色 :"+color;//return返回调用该方法的代码行
}
public String bark() {//
return "性别 :"+gender+" 姓名 :"+name+" 颜色 :"+color+" 叫声 :"+color;
}
public Dog(String gender, String name, String color) {//三个参数的方法
//super();
this.gender= gender;
this.name = name;
this.color = color;
}
public Dog(String gender, String name, String color, String call) {//四个参数的方法
super();
this.gender = gender;
this.name = name;
this.color = color;
this.call = call;
}
}
静态动态区分:
面向对象概述:
面向对象是人类最自然的一种思想方式,它将所有预处理的问题抽象为对象,通过了解这些对象具有哪些相应的属性以及展示这些对象的行为,以解决这些对象一些实际问题。
其实质上就是对现实世界中的对象进行建模操作。
面向对象程设计的特征:
封装、多态、继承
类:
类是封装对象的属性和行为的载体,而在Java语言中对象的属性以成员变量的形式存在,对象方法以成员方法的形式存在。
例题【6.1】为书添加属性
创建一个Book类,在类中设置一个name属性,并为该属性编写Getter/Setter方法。
public class Book{
private String name;
public String getName(){
return name;}
publie void setName(String name){
this.name=name;
}
什么是封装?
原则:对象代表什么,就得封装对应的数据,并提供数据对应的行为
理解:人画圆,是人调用了圆方法,所以人画圆,画圆该写在圆类中。人关门,在封装思想中,是门自己关的,人给作用力,门就自己关了。因为人的行为,所以造成的后果,所以在封装时,方法写在哪个类中很重要,可以更正确的设置对象的行为和属性。
什么是继承?
有封装才有继承
共性:写到父类
父类的所有代码,子类都可使用
个性:写到子类
当处理一个问题时,可以将一些有用的类保留下来,在遇到相同的问题时拿来复用。假如这时需要解决信鸽送信的问题,我们很自然就会想到鸽子属于鸟类,具有与鸟类相同的属性和行为,便可以再创建信鸽类时将鸟类拿来复用,并且保留鸟类具有的属性和行为。鸽子类保留了鸟类的属性和行为,这样就节省了定义鸟和鸽子共同具有的属性和行为的时间。
什么是多态?
有继承才有多态,其实将父类对象应用于子类的特征就是多态。
成员变量
在Java中,对象的属性也成为成员变量,成员变量可以是任意类型,整个类中均是成员变量作用范围。下面通过一个实例来演示成员变量在类中所处的位置。
public class Book{
privtae String name;//String类型的成员变量
public String getName(){//name的Getter方法
return name;
}
public void setName(String name){//name的Setter方法
this.name=name;//将参数值赋予类中的成员变量
}
}
在上面这个实例中可以看出,在java语言中需要使用class关键字来定义类,Book是类的名称。同时在Book类中定义了一个成员变量,成员变量的类型为String。其实成员变量就是普通的变量,可以为它设置初始值,也可以不设置初始值。不设置初始值,则会有默认值。
成员方法
在Java语言中使用,使用成员方法对应用类对象的行为。以Book为例,它包含getName()和setName()两个方法,这两个成员方法分别为获取图书名称和设置图书名称的方法。
定义成员方法的语法格式如下:
权限修饰符 返回值类型 方法名(参数类型 参数名){
……//方法体
return 返回值;
}
一个成员方法可以有参数,这个参数可以是对象也可以是对象,也可以是基本数据类型的变量,同时成员方法有返回值和不返回值的选择,如果方法需要返回值,可以在方法体中使用return关键字使用这个关键字后,方法的执行将被终止。
注意:要使Java代码中的成员方法无返回值,可以使用void关键字表示。
成员方法的返回值可以是计算结果,也可以是其他想要的数值和对象,返回值类型要与方法返回的值类型一致
权限修饰符
Java中的权限修饰符主要包括default、private、public和protected,这些修饰符控制着对类和类的成员变量以及成员方法的访问。如果一个类的成员变量或成员方法被修饰为private,则该成员变量只能在本类中北使用,在子类中是不可见的,并且并且其他包的类也是不可见的。如果将类的成员变量和成员方法访问权限设置为public,那么除了可以在本类使用这些数据,还可以在子类和其他包的类中使用。下图描述了default、private、public和protected的修饰权限。
注意:当声明类时不使用public、protected和private修饰符设置类的权限,则这个类预设为包存取范围,即只有一个包中的类可以访问这个类的成员变量或方法。
例如,在项目中的com.mr包下创建的AnyClass类,该类使用默认的访问权限。
package com.mr;
class AnyClass{
public void doString{
……//方法体
}
}
局部变量
局部变量时在方法被执行时创建,在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化,否则会出现编译错误。
【例题6.2】交换两个整数的值
package six;
abstract class ChangeDemo {
public static int[] exchange(int[] arr) {
int tmp=arr[0];//创建局部变量
arr[0]=arr[1];//第二个元素赋给第一个元素
arr[1]=tmp;//第二个元素改为tmp
return arr;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int arr[]= {17,29};
System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
arr=exchange(arr);
System.out.println("第一个值="+arr[0]+",第二个值="+arr[1]);
}
}
运行结果与代码截图如下:
局部变量的有效范围
可以将局部变量的有效范围称为变量的作用域,局部变量的有效范围从该变量的声明开始到该变量的结束为止。
注意:在作用范围外使用局部变量是一个常见的错误,因为在作用范围外没有声明局部变量的代码。
this关键字
this关键字用于表示本类当前的对象,当前对象不是某个new出来的实体对象,而是当前正在编辑的类。this关键字只能在本类中使用。
例
public void setName(String name){//定义一个setName()方法
this.name=name;//将参数赋予类中的成员变量
}
在上述代码中看到,成员变量与setName()方法中的形式参数的名称相同,都为name。在Java语言中,规定使用this关键字来代表苯类对象的引用,this关键字被隐式地用于引用对象的成员变量和方法,如在上述代码中,this.name指的就是Book类中的成员变量,而this.name=name语句中的第二个name指的是形参name。实质上,setName()方法实现的功能就是将形参name的值赋予成员变量name。
this除了可以调用成员变量或成员方法,还可以作为方法的返回值。例如,返回图书类本类的对象,可以写成下面的形式:
public Book getBook(){
return this//返回Book类本类的对象
}
在getBook()方法中,返回值为Book类,所以方法体中使用return this这种形式返回Book类对象。
类的构造方法
在类中,除成员方法外,还存在一种特殊类型的方法,那就是构造方法。构造方法是一个与类同名的方法吗,对象的创建就是通过构造方法完成的。每当类实例化一个对象时,类都会自动调用构造方法。
构造方法的特点如下:
构造方法没有返回值。
构造方法的名称要与本类的名称相同
注意:在定义构造方法时,构造方法没有返回值,但这与普通没有返回值的方法不同,普通没有返回值的方法是u哦那个public void methodEx()这种形式进行定义,但构造方法并不需要使用void关键字进行修饰。
构造方法的定义语法格式如下:
public Book(){
……//构造方法体
}
public:构造方法修饰符
Book:构造方法的名称
在构造方法中可以为成员变量赋值,这样当实例化一个本类对象时,相应的成员变量也将被初始化。如果类中没有明确定义构造方法,编译器会自动创建一个不带参数的默认构造方法。
注意:如果在类中定义的构造方法都不是无参的构造方法,那么编译器也不会为类设置一个默认的无参构造方法,当试图调用无参构造方法实例化一个对象时,编译器会报错。所以,只有在类中没有定义任何构造方法时,编译器才会在该类中自动创建一个不带参数的构造方法
【例题6.3】
package six;
import java.util.Scanner;
public class EggCake {
int eggCount;//鸡蛋灌饼里的个数
public EggCake(int eggCount) {//参数为鸡蛋灌饼里蛋的个数的构造方法
this.eggCount=eggCount;//将参数eggCount的值付给属性eggCount
}
public EggCake() {//无参数构造方法,默认给饼加一个鸡蛋
//调用参数为鸡蛋灌饼里蛋的个数的构造方法,并设置鸡蛋灌饼里的个数为1
this(1);
}
public static void main(String[] args) {
EggCake cake1=new EggCake();
System.out.println("顾客不要求加蛋的数量,饼里会有"+cake1.eggCount+"个蛋");
EggCake cake2=new EggCake(2);
System.out.println("顾客要求加2个蛋,饼里会有"+cake2.eggCount+"个蛋");
}
}
代码与输出截图如下:
静态变量和静态方法
被声明为static的变量和方法被称为静态成员。静态成员属于类所有,区别于个别对象,可以在本类或其他类使用类名和“.”运算符调用静态成员,语法如下:
类名.静态类成员
【例题6.4】创建并调用静态属性和静态变量
package six;
public class StaticDemo {
static double PI=3.1415;//在类中定义静态变量
//静态:类专属的,必须用类名.方法(变量)才能调用静态变量
//final修饰的是常量
static final double Pai=3.14; //静态常量
public static void method() {//在类中定义静态方法
System.out.println("这是静态方法");
}
public static void main (String[]args) {
System.out.println(StaticDemo.PI);//调用静态变量
StaticDemo.method();//调用静态方法
}
}
package six;
public class StaticDemo {
static double PI=3.1415;//在类中定义静态变量
//静态:类专属的,必须用类名.方法(变量)才能调用静态变量
//final修饰的是常量
static final double Pai=3.14; //静态常量
public static void method() {//在类中定义静态方法
System.out.println("这是静态方法");
}
public static void main (String[]args) {
System.out.println(StaticDemo.PI);//调用静态变量
//System.out.println(StaticDemo.Pai);//调用静态常量
StaticDemo.method();//调用静态方法
}
}
注意:虽然静态成员也可以使用“对象.静态成员”的形式进行调用,但通常不建议用这样的形式,因为这样容易混淆静态成员和非静态成员
【例6.5】统计顾客总人数
package six;
public class Cust {//顾客类
static int count=0;//共享的属性,人数
String name;//名称属性
public Cust(String name) {
this.name=name;//记录名称
count++;//人数递增
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Cust c1=new Cust("tom");
System.out.println("我是第"+Cust.count+"名顾客,我叫"+c1.name);
Cust c2=new Cust("张三");
System.out.println("我是第"+Cust.count+"名顾客,我叫"+c2.name);
Cust c3=new Cust("狗蛋儿");
System.out.println("我是第"+Cust.count+"名顾客,我叫"+c3.name);
}
}
输出与代码截图如下:
类的主方法
主方法时类的入口点,它定义了程序从何处开始。主方法语法如下:
public static void main(String []args){
……//方法体
}
在主方法定义中可以看到具有以下特性:
主方法是静态的,所以如要直接在主方法中调用其他方法,则该方法必须也是静态的。
主方法没有返回值
主方法的形参为数组。其中,arg[0]~args[n]分别代表程序的第一个参数到第n个参数,可以使用args.length获取参数的个数
【例题6.6】读取主方法的参数值
package six;
public class MainDemo {
public static void main(String[] args) {//定义主方法
// TODO Auto-generated method stub
for(int i=0;i<args.length;i++) {//根据参数个数做循环操作
System.out.println(args[i]);//循环打印参数内容
}
}
}
运行结果及代码截图如下:
对象
对象的创建
Test test =new Test();
Test test=new Test("a");
【例题6.7】创建人类并创建其对象
package six;
public class People {
String name;
int age;
String sex;
public People() {
}
public People(String name,int age,String sex) {
this.name=name;
this.age=age;
this.sex=sex;
}
public static void main(String[]args) {
People p1=new People("tom",23,"男");
People p2=new People("lily",19,"女");
}
}
访问对象的属性和行为
【例6.8】
package six;
public class Dog {
String name;//狗
String Color;//颜色
String vioce;//声音
public Dog(String name,String Color,String vioce) {
this.name=name;
this.Color=Color;
this.vioce=vioce;
}
public void call(){
System.out.println(vioce);//叫
}
public static void main(String[] args) {
Dog d1=new Dog("毛毛","白色","汪汪汪");
System.out.print(d1.name+"的颜色是"+d1.Color);//访问对象的属性
System.out.print(",叫起来的声音:");
d1.call();//访问对象的行为
Dog d2=new Dog("灰灰","灰色","嗷呜~");
System.out.print(d2.name+"的颜色是"+d2.Color);//访问对象的属性
System.out.print(",叫起来的声音:");
d2.call();
}
}
代码截图与输出如下:
对象的引用
引用的语法:
类名 对象的引用变量
例如:
People tom;
关联语法如下
People tom=new People();