Java语言基础(12)

1 构造方法重载

　　在一个类内部，编写多个构造方法，创建对象的时候，根据需求的不同，调用不同的构造方法创建对象，实现不同的初始化。

　　案例：Demo1

public class Demo1 {
  public static void main(String[] args) {
//	长方体
	Box box1 = new Box(100,60,90);
	box1.show();
	box1.showTiji();
//	正方体
	Box box2 = new Box(100);
	box2.show();
	box2.showTiji();
  }
}
class Box{
//属性
  int length;
  int width;
  int height;
//构造方法
//长方体
  Box(int length,int width,int height){
	this.length = length;
	this.width = width;
	this.height = height;
  }
//正方体
  Box(int length){
	this.length = length;
	this.width = length;
	this.height = length;
  }
//方法：
  void show(){
	System.out.println(length+","+width
			+","+height);
  }
  void showTiji(){
	int result = length * width * height;
	System.out.println("体积是"+result);
  }
}

public class Demo2 {
  public static void main(String[] args) {
	Customer cus1 =
		new Customer("韩信",33,"将军");
	cus1.show();
	Customer cus2 =
		new Customer("李白",21,"诗人",
			"123","洛阳","bai@126.com");
	cus2.show();
	cus2.showAll();
  }
}
class Customer{
//属性
  String name;
  int age;
  String job;
  String password;
  String address;
  String email;
//构造方法
  Customer(String name,int age,
		  					 String job){
	this.name = name;
	this.age = age;
	this.job = job;
  }
  Customer(String name,int age,
		  String job,String password,
		  String address,String email){
	this.name = name;
	this.age = age;
	this.job = job;
	this.password = password;
	this.address = address;
	this.email = email;
  }
//方法
  void show(){
	System.out.println(name+","+age+","
			+job);
  }
  void showAll(){
	System.out.println(name+","+age+","
		+job+","+password+","+address
		+","+email);
  }
}

2 static

　　静态的，可以用来修饰属性，方法以及代码块。
　　1）静态变量(静态属性)：使用static修饰的属性，称为静态变量，静态变量在内存中单独开辟存储空间，不依赖于对象而存在，可以通过类名.静态变量名直接进行访问。
　　　　访问方式：
　　　　　　类名.静态变量名
　　　　　　或者
　　　　　　对象名.静态变量名
　　　　案例：Demo3

public class Demo3 {
  public static void main(String[] args) {
//类名.静态变量名
	System.out.println(Foo.name);
//	System.out.println(Foo.age);
//age是一个普通属性，只有在创建对象以后，才会为age
//属性开辟存储空间。必须先有对象，然后才可以访问age
//属性
//对象名.静态变量名
	Foo foo = new Foo();
	System.out.println(foo.name);
	System.out.println(foo.age);
  }
}
class Foo{
//静态变量不依赖于对象而存在，内存中单独开辟存储空间，
//可以通过类名.静态变量名直接访问。
  static String name = "张三";//静态变量
  int age = 21;//普通属性
}

　　2）静态方法：使用static修饰的方法，称为静态方法，不依赖于对象而存在，可以通过类名.静态方法名(参数)直接访问。
　　　　案例：Demo4

public class Demo4 {
  public static void main(String[] args) {
//类名.静态方法名(参数)
	Koo.f1();
//对象名.静态方法名(参数)
	Koo koo = new Koo();
	koo.f1();
  }
}
class Koo{
  static void f1(){
	System.out.println("今天天气很好！");
  }
}

　　　　访问方式：
　　　　　　类名.静态方法名(参数)
　　　　　　或者
　　　　　　对象名.静态方法名(参数)
　　3）如果main方法跟静态方法在同一个类中，在main方法中，可以直接使用静态方法名(参数)来访问静态方法。
　　　　案例：Demo5

public class Demo5 {
  static void f1(){
	System.out.println("今天风真大！");
	System.out.println("静态方法");
  }
  public static void main(String[] args) {
	f1();
  }
}

public class Demo6 {
  public static void main(String[] args) {
	for(int i=1;i<=100;i++){
	  double num = Math.random();
	  System.out.println(num);
	}
  }
}

　　4）sun设计的工具类中经常使用到静态方法，用户可以不用创建该工具类的对象，就可以访问这些静态方法，使用方便。
　　　　Math（数学）是sun公司设计的一个工具类，Math内部所有的方法都是静态方法。
　　　　random():是一个静态方法，用来返回一个随机的小数，取值范围在[0.0,1.0)
　　　　案例：Demo7

public class Demo7 {
//创建一个double类型数组ary，包含200个元素，通过
//Math.random()生成的随机给数组元素赋值。最后
//使用两种for循环，输出每一个元素的值。
  public static void main(String[] args) {
	double[] ary = new double[200];
	for(int i=0;i<=ary.length-1;i++){
	  ary[i] = Math.random();
	}
	for(int i=0;i<=ary.length-1;i++){
	  System.out.println(ary[i]);
	}
	System.out.println();
	System.out.println();
	System.out.println();
	for(double num : ary){
	  System.out.println(num);
	}
  }
}

public class Demo8 {
//在main方法中，创建一个包含了100个元素的double
//类型的数组，使用Math.random()生成的随机数给
//数组元素赋值。
//1 使用两种for循环输出每一个元素的值
//2 求出所有元素的累加之和
//3 求出元素的平均值
  public static void main(String[] args) {
	double[] ary = new double[100];
	for(int i=0;i<=ary.length-1;i++){
	  ary[i] = Math.random();
	  System.out.println(ary[i]);
	}
	System.out.println();
	for(double num:ary){
	  System.out.println(num);
	}
	double sum = 0;
	for(double num:ary){
	  sum = sum + num;
	}
	System.out.println("累加之和："+sum);
	double avg = sum/100;
	System.out.println("平均值是："+avg);
  }
}

　　5）代码块：使用{}括起来的一段代码，每次创建对象的时候都会默认的调用代码块一次。
　　　　案例：Demo9

public class Demo9 {
  public static void main(String[] args) {
	Eoo eoo1 = new Eoo();
	Eoo eoo2 = new Eoo();
	Eoo eoo3 = new Eoo();
  }
}
class Eoo{
	{
		System.out.println("海阔天空");
		System.out.println("我变了 我没变");
		System.out.println("喜欢你");
	}
}

　　6）静态代码块：使用static修饰的代码块称为静态代码块，不管创建该类多少个对象，静态代码块只执行一次。
　　　　案例：Demo10

public class Demo10 {
  public static void main(String[] args) {
	Moo moo1 = new Moo();
	Moo moo2 = new Moo();
	Moo moo3 = new Moo();
  }
}
class Moo{
	static{
		System.out.println("围城");
		System.out.println("幻城");
		System.out.println("三重门");
	}
}

　　　　经常使用静态代码块来保存连接数据库的信息，比如密码...

3 this

　　当前的，现在的
　　1）this.属性：指代当前的属性。
　　2）this(参数)：在当前的构造方法中，调用本类中其他的构造方法。跟构造方法重载结合使用。
　　　　必须在当前构造方法的第1行使用。
　　　　案例：Demo11

public class Demo11 {
  public static void main(String[] args) {
	Person p1 =
		new Person("乔峰",33,"帮主",
				  "襄阳","feng@126.com");
	p1.show();
  }
}
class Person{
//属性
  String name;
  int age;
  String job;
  String address;
  String email;
//构造方法
  Person(String name,int age,String job,
		  String address){
	this.name = name;
	this.age = age;
	this.job = job;
	this.address = address;
  }
//给每一个属性赋值
  Person(String name,int age,String job,
		  String address,String email){
//this(参数)：在当前的构造方法中调用本类中其他的
//构造方法。必须在当前构造方法的第1行使用。
	this(name,age,job,address);
	this.email = email;
  }
//方法：
  void show(){
	System.out.println(name+","+age+","
			+job+","+address+","+email);
  }
}

public class Demo12 {
  public static void main(String[] args) {
	User user =
		new User("张三",29,"经理",
				  "abc",30000.99,"北京");
	user.show();
	user.showAll();
  }
}
class User{
//属性
  String name;
  int age;
  String job;
  String password;
  double salary;
  String address;
//构造方法
  User(String name,int age,String job){
	this.name = name;
	this.age = age;
	this.job = job;
  }
  User(String name,int age,String job,
		  String password,double salary,
		  String address){
	this(name,age,job);
	this.password = password;
	this.salary = salary;
	this.address = address;
  }
//方法
  void show(){
	System.out.println(name+","+age+","
			+job);
  }
  void showAll(){
//this.方法名(参数)：在当前的方法中，调用本类中
//其他的方法
	this.show();
	System.out.println("密码："+password);
	System.out.println("工资："+salary);
	System.out.println("地址："+address);
  }
}

　　3）this.方法名(参数)：在当前方法中调用本类的其他方法

4 继承

　　继承的本质就是代码的“复制”。
　　案例：Demo13

public class Demo13 {
  public static void main(String[] args) {
	Person2 p1 = new Person2();
	p1.name = "李世民";
	p1.age = 32;
	p1.address = "长安";
	p1.show();
	Teacher t1 = new Teacher();
	t1.name = "李治";
	t1.age = 21;
	t1.address = "洛阳";
	t1.salary = 20000.1;
	t1.email = "zhi@126.com";
	t1.show();
	t1.showAll();
  }
}
class Person2{//父类
//属性
  String name;
  int age;
  String address;
//方法
  void show(){
	System.out.println(name+","+age+","
			+address);
  }
}
//class 子类 extends 父类
class Teacher extends Person2{//子类
//属性：姓名，年龄，地址，工资，邮箱
//继承父类Person2中的姓名，年龄，地址
  double salary;
  String email;
//方法：
//继承父类中show()方法
  void showAll(){
	this.show();//调用父类中继承过来show()方法
	System.out.println("工资："+salary);
	System.out.println("邮箱："+email);
  }
}

　　1）子类会继承父类中所有的属性和方法
　　2）格式：
　　　　class 子类 extends 父类{
　　　　　　继承父类的属性和方法
　　　　　　在子类中编写其他的属性和方法。
　　　　}
　　　　案例：Demo14

public class Demo14 {
  public static void main(String[] args) {
	Worker worker = new Worker();
	worker.name = "张翠山";
	worker.job = "大侠";
	worker.age = 31;
	worker.address = "冰火岛";
	worker.phone = "13333333333";
	worker.salary = 200000.1;
	worker.show();
	worker.showYearSal();
	worker.showAll();
  }
}
class Emp{
//属性
  String name;
  int age;
  String job;
  double salary;
//方法
  void show(){
	System.out.println(name+","+age+","+
			job+","+salary);
  }
  void showYearSal(){
	double result = salary * 12;
	System.out.println(name+"的年薪是"+
			result);
  }
}
//设计一个父类Emp
//属性：姓名，年龄，职位，工资
//方法：void show():输出姓名，年龄，职位，工资
//void showYearSal():输出姓名和年薪（工资*12）
class Worker extends Emp{
//属性
  String address;
  String phone;
//方法
  void showAll(){
	this.show();
	System.out.println("地址："+address);
	System.out.println("电话："+phone);
  }
}

　　3）Java中永远是单继承，一个子类只能有一个直接的父类，但是可以层层继承。
　　　　案例：Demo15

public class Demo15 {
  public static void main(String[] args) {
	Foo4 foo = new Foo4();
	System.out.println(foo.num1);
	System.out.println(foo.num2);
	System.out.println(foo.num3);
	System.out.println(foo.num4);
  }
}
class Foo1{
  int num1=100;
}
class Foo2 extends Foo1{
//num1
  int num2=200;
}
class Foo3 extends Foo2{
//num1,num2
  int num3=300;
}
class Foo4 extends Foo3{
//num1,num2,num3
  int num4=400;
}