封装性
封装的原则：将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供的对应的getXxx() 和 setXxx() 方法
封装的好处：
1、通过方法来控制成员变量的操作，提高了代码的安全性
2、把代码用方法进行封装提高了代码的复用性
继承性
继承是面向对象三个特征之一。可以使子类具有父类的属性和方法，还可以在子类重新定义，追加属性和方法。
继承的好处
提高了代码的复用性（多个类相同的成员可以放到同一类中）
提高了代码的维护性（修改一处多处修改）
多态性
同一个对象，不同时刻表现出来的不同形态
多态的分类：具体类多态、抽象类多态、接口多态

6.2类与对象

成员变量：可以是变量，可以是常量
构造方法：有构造方法但是本身不能实例化，用于子类访问父类数据初始化（多态的方式实例化）
成员方法：
1，可以是抽象方法，限定子类必须重写
2，还可以上非抽象方法，提高代码的复用性

6.2.2成员方法

例6.1

代码

public static void main(String[] args) {
		// TODO Auto-generated method stub
		WWW1 book = new WWW1 ();//创建对象
	    int x = 30;//定义实参变量x
	    int y = 40;//定义实参变量y
	    System.out.println("运算结果：" + book.add(x, y));//输出运算结果
	    System.out.println("实参x的值："+x);//输出实参x的值
	}
	private int add(int x, int y)//计算两个数的和
	{
	    x = x + y;//对x进行加y操作
	    return x;//返回x


	}

}

结果

例6.2

代码


public class www2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		www2 refTest = new www2();//创建对象
        int[] i = { 0, 1, 2 }; //定义一维数组，作为方法的实参
        //输出一维数组的原始元素值
        System.out.print("原始数据：");
        for (int j = 0; j < i.length; j++)
        {
            System.out.print(i[j]+" ");
        }
        refTest.change(i);//调用方法改变数组元素的值
        System.out.print("\n修改后的数据：");
        for (int j = 0; j < i.length; j++)
        {
            System.out.print(i[j]+" ");
        }
	}
	//定义一个方法，方法的参数为一维数组（形参）
	public void change(int [] i)
    {
        i[0] = 100;
        i[1] = 200;
        i[2] = 300;


	}

}

结果

例6.3

代码

结果

例6.4

代码

public class WWW4 {

	public void gaze(String target) {// 凝视。目标是参数target
		// TODO Auto-generated method stub
		System.out.println("猎豹凝视：" + target);
	}
 
	public void run() {// 奔跑
		System.out.println("猎豹开始奔跑");
	}
 
	public boolean catchPrey(String prey) {// 捕捉猎物，返回捕捉是否成功
		System.out.println("猎豹开始捕捉" + prey);
		return true;// 返回成功
	}
 
	public void eat(String meat) {// 吃肉，参数是肉
		System.out.println("猎豹吃" + meat);
	}
 
	public void sleep() {// 睡觉
		System.out.println("猎豹睡觉");//输出
	}
 
	public static void main(String[] args) {//主函数
		WWW4 liebao = new WWW4();//文件名
		liebao.gaze("羚羊");
		liebao.run();
		liebao.catchPrey("羚羊");
		liebao.eat("羚羊肉");
		liebao.sleep();

	}

}

结果

6.2.3构造方法

例6.5

代码


public class WWW5 {
		private  WWW5() {
		}
				// 静态公开方法，向图书馆借书
				static public WWW5 libraryBorrow() { // 创建静态方法，返回本类实例对象
					System.out.println("通过调用静态方法创建对象");
					return new WWW5();
				}
	 
			public static void main(String[] args) {//主函数
					// 创建一个书的对象，不是new实例化的，而是通过方法从图书馆借来的
				WWW5 book = WWW5.libraryBorrow();//输出

	}

}

结果

6.2.4 局部变量

6.2.5局部变量的有效范围

可以将局部变量的有效范围称为变量的作用域局部变量的有效范围从该变量的声明开始到该变量的结束为止

6.2.6 对象的创建

Test test=new Test();

Test test=new Test("a"); y

Test:类名。test:创建 Test类对象。 new:创建对象操作符。 a:构造方法的参数。

例6.6

代码

结果

6.2.7访问对象的属性和行为

用户使用 new 操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。前文已经提到过，对象的属性和行为在类中是通过类成员变量和成员方法的形式来表示的，所以当对象获取类成员时，也相应地获取了对象的属性和行为。

例6.7

代码

public class WWW7 {

		int i = 47; // 定义成员变量
		 
		public void call() { // 定义成员方法
			System.out.println("调用call()方法");
			for (i = 0; i < 3; i++) {
				System.out.print(i + " ");
				if (i == 2) {
					System.out.println("\n");
				}
			}
		}
 
		public WWW7() { // 定义构造方法
		}
 
		public static void main(String[] args) {
			WWW7 t1 = new WWW7(); // 创建一个对象
			WWW7 t2 = new WWW7(); // 创建另一个对象
			t2.i = 60; // 将类成员变量赋值为60
			// 使用第一个对象调用类成员变量
			System.out.println("第一个实例对象调用变量i的结果：" + t1.i);
			t1.call(); // 使用第一个对象调用类成员方法
			// 使用第二个对象调用类成员变量
			System.out.println("第二个实例对象调用变量i的结果：" + t2.i);
			t2.call(); // 使用第二个对象调用类成员方法


	}

}

结果

6.2.8对象的销毁

每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址会被回收。在其他语言中需要手动回收废弃的对象，但是Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器将回收无用的但占用内存的资源。
在谈到垃圾回收机制之前，首先需要了解何种对象会被 Java 虚拟机视为垃圾。主要包括以下两种情况:

(1)对象引用超过其作用范围，这个对象将被视为垃圾。

(2)将对象赋值为null。

6.2.9 this关键字

例6.8

代码

public class WWW8 {
	String name="abc";
	public void showName(String name) {
		System.out.println(name);
	}

	public static void main(String[] args) {
		WWW8 book = new WWW8();
		book.showName("123");


}
}

结果

例6.9

代码

public class WWW9 {
	String name = "abc";
	 
	public void showName(String name) {
		System.out.println(this.name);
	}

	public static void main(String[] args) {
		WWW9 book = new WWW9();
		book.showName("123");

}
}

结果

例6.10

代码

public class WWW10 {
		int eggCount;// 鸡蛋灌饼里有几个蛋
		 
		// 有参数构造方法，参数是给饼加蛋的个数
		public WWW10(int eggCount) {
			this.eggCount = eggCount;
			System.out.println("这个鸡蛋灌饼里有" + eggCount + "个蛋。");
		}
 
		// 无参数构造方法，默认给饼加一个蛋
		public WWW10() {
			this(1);
		}
 
		public static void main(String[] args) {
			WWW10 cake1 = new WWW10();
			WWW10 cake2 = new WWW10(5);
	}

}

结果

6.3.1 静态变量

很多时候，不同的类之间需要对同一个变量进行操作，比如一个水池，同时打开入水口和出水，进水和出水这两个动作会同时影响到池中的水量，此时池中的水量就可以认为是一个共享的变量。在Java 程序中，把共享的变量用 static 修饰，该变量就是静态变量。

例6.11

代码

public class WWW11 {
	static public int water = 0;
	public void outlet() {// 放水，一次放出2个单位
		if (water >= 2) {
			water = water - 2;
		} else {
			water = 0;
		}
	}

	public void inlet() {// 注水，一次注入3个单位
		water = water + 3;
	}
	public static void main(String[] args) {//主函数
		WWW11 out = new WWW11();
		WWW11 in = new WWW11();
		System.out.println("水池的水量：" + WWW11.water);
		System.out.println("水池注水两次。");
		in.inlet();
		in.inlet();
		System.out.println("水池的水量：" + WWW11.water);
		System.out.println("水池放水一次。");
		out.outlet();
		System.out.println("水池的水量：" + WWW11.water);

	}
}

结果

例6.12

代码

public class WWW12 {
	static int x;// 静态变量
	int y;// 普通成员变量

	public WWW12(int x, int y) {// 构造函数
		this.x = x;
		this.y = y;
	}

	public static void main(String[] args) {
	    WWW12 a = new WWW12(1, 2);
		WWW12 b = new WWW12(13, 17);
		System.out.println("a.x的值是 = " + a.x);
		System.out.println("a.y的值是 = " + a.y);
		System.out.println("b.x的值是 = " + b.x);
		System.out.println("b.y的值是 = " + b.y);

	}
}

结果

6.3.2 静态常量

例6.13

代码

public class WWW13 {
	final static double PI = 3.1415926;// 创建静态常量π
	public static void main(String[] args) {
		double radius = 3.0;// 半径
      double area = WWW13.PI * radius * radius;// 计算面积
		double volume = 4 / 3 * WWW13.PI * radius * radius * radius;// 计算体积
		Circular yuan = new Circular(radius, area);
		Spherical qiu = new Spherical(radius, volume);
	}
}
class Circular {
	double radius;// 半径
	double area;// 面积
	public Circular(double radius, double area) {
		this.radius = radius;
		this.area = area;
		System.out.println("圆的半径是：" + radius + ",圆的面积是：" + area);
	}
}
class Spherical {
	double radius;// 半径
	double volume;// 体积
	public Spherical(double radius, double volume) {
		this.radius = radius;
		this.volume = volume;
		System.out.println("球的半径是：" + radius + ",球的体积是：" + volume);

}
}

结果

6.3.3 静态方法

例6.14

代码

public class WWW14 {
	static public void show() {//定义静态方法
		System.out.println("静态方法无需实例化就可以调用");
	}
	public static void main(String[] args) {
		WWW14.show();//使用类名调用静态方法
}

}

结果

6.3.4 静态代码块

例6.15

代码

public class WWW15 {
	static String name;
	//静态代码块
	static {
		System.out.println(name + "静态代码块");
	}
	//非静态代码块
	{
		System.out.println(name+"非静态代码块");
	}

	public WWW15(String a) {
		name = a;
		System.out.println(name + "构造方法");
	}

	public void method() {
		System.out.println(name + "成员方法");
	}

	public static void main(String[] args) {
		WWW15 s1;// 声明的时候就已经运行静态代码块了
		WWW15 s2 = new WWW15("s2");// new的时候才会运行构造方法
	    WWW15 s3 = new WWW15("s3");
		s3.method();//只有调用的时候才会运行
}

}

结果