第六章总结

java。。

已于 2023-04-17 09:36:37 修改

阅读量48

点赞数 1

文章标签： java 开发语言

于 2023-04-01 20:54:33 首次发布

本文链接：https://blog.csdn.net/weixin_74767865/article/details/129660653

版权

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();

java。。

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第六章总结

面向对象是人类最自然的一种思想方式，它将所有预处理的问题抽象为对象，通过了解这些对象具有哪些相应的属性以及展示这些对象的行为，以解决这些对象一些实际问题。其实质上就是对现实世界中的对象进行建模操作。封装、多态、继承原则：对象代表什么，就得封装对应的数据，并提供数据对应的行为理解：人画圆，是人调用了圆方法，所以人画圆，画圆该写在圆类中。人关门，在封装思想中，是门自己关的，人给作用力，门就自己关了。因为人的行为，所以造成的后果，所以在封装时，方法写在哪个类中很重要，可以更正确的设置对象的行为和属性。
复制链接

扫一扫