6.1 面向对象概述
6.1.1 对象
通常都会将对象划分为两个部分，即静态部分与动态部分。
识别这个对象的属性 如
识别出这个对象的动态行为
类和对象之间的关系
6.1.2 类
类是同一类事物的统称
类是构造对象时所依赖的的规范，对象就是符合某个类的定义所产生出来的实例
类是 封装对象的属性 和 行为的载体，反过来说，具有相同属性和行为的一类实体被称为类。
6.1.3 封装
封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装思想。
6.1.4 继承
从图6.6中可以看出，继承关系可以使用树形关系来表示，父类与子类存在一种层次关系。
6.1.5 多态
其实将对象应用于子类的特征就是多态。
6.2 类
6.2.1 成员变量
对象的属性也称为成员变量
例题6.1
package six;
public class 例p96 { //类
private String name; //String 类型的成员变量
public String getName() { //name 的 get 方法
return name; //
}
public void setName(String name) { //name 的 set 方法
this.name = name; //将参数的值赋予类中的成员变量
}
}
6.2.2 成员方法
使用成员方法对应于类对象的行为
语法如下：
权限修饰符 返回值类型 方法名（）{
... ... //方法体
return 返回值；
}
6.2.3 权限修饰符
Java中的权限修饰符主要包括private、public和protected,这些修饰符控制着对类和类的成员变量以及成员方法的访问。
例如：
package com.mr;
class Anyclass{
public void doString(){
....... //方法体
}
}
6.2.4 局部变量
如果在成员方法内定义一个变量，那么这个变量被称为局部变量。
局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误。
例题：
package six;
public class 例p99 {
public static int[] exchange(int[] arr) {
int tmp = arr[0];
arr[0] = arr[1];
arr[1] = tmp;
return arr;
}
public static void main(String[] args) {
int arr[] = {17,29};
System.out.println("第一个值=" + arr[0] + "第二个值=" + arr[1]);
arr = exchange(arr);
System.out.println("第一个值=" + arr[0] + "第二个值=" + arr[1]);
}
}
6.2.5 局部变量
可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从变量声明开始到该变量结束为止。
6.2.6 this关键字
this关键字用于表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用。
例如：
public void setName(String[] name){ //定义一个 setName() 方法
this.name = name; //将参数值赋予类中的成员变量
}
其实，this除了可以调用成员变量或成员方法，还可以作为方法的返回值。例如，返回图书类本类的对象，可以写成：
public Book getBook(){
return this; //返回 Book 类的本对象
}
6.3 类的构造方法
构造方法的特点如下：
构造方法没有返回值。
构造方法的名称要与本类的名称相同。
构造方法的定义如下：
public Book(){
... //方法体
}
public: 构造方法修饰符
Book：构造方法的名称
例题 6.3：
package six;
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) {
// TODO Auto-generated method stub
EggCake cake = new EggCake();
System.out.println("顾客不要求加鸡蛋的数量，饼里会有" + cake.eggCount + "个蛋");
EggCake cake1 = new EggCake(2);
System.out.println("顾客要求加2个鸡蛋，饼里会有" + cake1.eggCount + "个蛋");
}
}
6.4 静态变量和静态方法
由 static 修饰的变量和方法被称为静态变量和静态方法。
例题6.4:
package six;
public class StaticDemo {
//静态变量
static double PI = 3.1415926; //在类中定义静态变量
static void method() { //在类中定义静态方法
System.out.print("静态方法");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(StaticDemo.PI); //调用静态变量
StaticDemo.method(); //调用静态方法
}
}
但静态成员同样遵循着 public、private、和 protected 修饰符的约束。
例题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) {
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);
Cust c4 = new Cust("郭鹏");
System.out.println("我是第" + Cust.count + "名顾客，我叫" + c4.name);
}
}
6.5 类的主方法
主方法是类的入口点，它定义了程序从何处开始。主方法提供对程序流向的控制，Java 编译器通过主方法来执行程序。主方法的语法如下：
public static void main(String[] args){
... //主方法
}
例题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]);
}
}
}
6.6 对象
6.6.1 对象的创建
在 Java 语言中，通过new操作符来创建对象。准确的说，在 Java 语言中使用 new 操作符调用构造方法创建对象。语法如下：
Test test = new Test();
Test test = new Test("a");
例题 6.7
package six;
public class People {
//成员变量
private String name;//姓名
private int age;//年龄
private String gender;//性别
private double height;//身高
private double weight;//体重
//get和set方法
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
// public static void main(String[] args) {
// String a = code("java");
// System.out.println(a);
// }
//成员方法
public String code(String language) {
return name + "正在写" + language + "代码";
}
public String introduce() {
return name + "年龄" + age + "，性别" + gender + "，身高" + height + "，体重" + weight;
}
public double getBMI() {
// double a = 0;
// a = weight/(height*height);
// return a;
return weight/(height*height);
}
//构造方法
public People(String name,int age,String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//自动生成
public People(String name, int age, String gender, double height, double weight) {
this.name = name;
this.age = age;
this.gender = gender;
this.height = height;
this.weight = weight;
}
}
6.6.2 访问对象的属性和行为
例题 6.8
package six;
public class Dog {
//成员变量
String gender;//性别
String name;//名字
String color;//颜色
String call;//叫声
//构造函数 无参
public Dog (String gender,String name,String color) {
this.gender = gender;
this.name = name;
this.color = color;
}
public Dog(String gender,String name,String color,String call) {
this.gender = gender;
this.name = name;
this.color = color;
this.call = call;
}
}
package six;
public class DogTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//使用有三个参数的构造方法新建对象
Dog P1 = new Dog("公","小蓝","蓝");
//调用成员方法introduce并打印
String introduce = P1.introduce();
System.out.println(introduce);
//使用有四个参数的构造方法新建对象
Dog P2 = new Dog("母","小红","红色","汪汪");
//调用成员方法bark并打印
String bark = P2.bark();
System.out.println(bark);
}
}
6.6.3 对象的引用
对象名的引用
People tom;
通常一个引用不一定需要有一个对象相关联。引用与对象相关联的语法如下：
People tom = new People();
7. 总结
这一章主要讲了类和对象，很难理解，需要多多回顾。
424
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
