Java语言基础(15)

1 综合案例

　　Demo1

设计一个父类Shape(图形类)，抽象类
常量：public static final double PI = 3.14;
抽象方法：void show()：输出每一个属性值
void showArea():输出面积
void showPerimeter():输出周长
编写子类Circle(圆)，继承Shape
属性：半径(double r) 构造方法：给属性赋值
方法：重写所有的抽象方法
圆面积：PI * r * r 圆周长：2 * PI * r
编写子类Rect(长方形),继承Shape
属性：长，宽 构造方法：给属性赋值
方法：重写所有的抽象方法
编写子类Square(正方形),继承Shape
属性：边长(int length) 构造方法：给属性赋值
方法：重写所有的抽象方法
在main方法，分别创建对象，并调用其方法。

public class Demo1 {
  public static void main(String[] args) {
	Shape circle = new Circle(10.0);
	circle.show();
	circle.showArea();
	circle.showPerimeter();
	Rect rect= new Rect(100,80);
	rect.show();
	rect.showArea();
	rect.showPerimeter();
	Square squ = new Square(100);
	squ.show();
	squ.showArea();
	squ.showPerimeter();
  }
}
/*
设计一个父类Shape(图形类)，抽象类
常量：public static final double PI = 3.14;
抽象方法：void show()：输出每一个属性值
void showArea():输出面积
void showPerimeter():输出周长
编写子类Circle(圆)，继承Shape
属性：半径(double r)             构造方法：给属性赋值
方法：重写所有的抽象方法
圆面积：PI * r * r     圆周长：2 * PI * r
编写子类Rect(长方形),继承Shape
属性：长，宽		   构造方法：给属性赋值
方法：重写所有的抽象方法
编写子类Square(正方形),继承Shape
属性：边长(int length)            构造方法：给属性赋值
方法：重写所有的抽象方法
在main方法，分别创建对象，并调用其方法。
*/
abstract class Shape{
//常量
  public static final double PI = 3.14;
//抽象方法
  abstract void show();
  abstract void showArea();
  abstract void showPerimeter();
}
class Circle extends Shape{
//属性
  double r;
//构造方法
  Circle(double r){
	this.r = r;
  }
//方法
  @Override
  void show() {
    System.out.println("半径："+r);
  }
  @Override
  void showArea() {
	double result = PI * r * r;
	System.out.println("圆的面积是"+result);
  }
  @Override
  void showPerimeter() {
	double result = 2 * PI * r;
	System.out.println("圆的周长是"+result);
  }
}
class Rect extends Shape{
//属性
  int length;
  int width;
//构造方法
  Rect(int length,int width){
	this.length = length;
	this.width = width;
  }
  @Override
  void show() {
	System.out.println("长："+length);
	System.out.println("宽："+width);
  }
  @Override
  void showArea() {
	int result = length * width;
	System.out.println("面积是"+result);
  }
  @Override
  void showPerimeter() {
	int result = 2*(length+width);
	System.out.println("周长是"+result);
  }

}
class Square extends Shape{
//属性
  int length;
//构造方法
  Square(int length){
	this.length = length;
  }
//方法
  @Override
  void show() {
	System.out.println("边长是："+length);
  }
  @Override
  void showArea() {
	int result = length * length;
	System.out.println("面积是"+result);
  }
  @Override
  void showPerimeter() {
	int result = 4 * length;
	System.out.println("周长是"+result);
  }
}

2 接口

　　接口是一种特殊的引用数据类型，设计的工具。
　　1）接口的组成：常量和抽象方法
　　2）格式1：
　　　　interface 接口名{
　　　　　　//常量
　　　　　　public static final 数据类型 常量名=数值;
　　　　　　//抽象方法:public
　　　　　　public abstract 返回值类型 方法名(参数列表);
　　　　}
　　　　eg:
　　　　　　interface Car{
　　　　　　　　常量：
　　　　　　　　public static final double MAX_PRICE = 2000000.1;
　　　　　　　　public static final double MIN_PRICE = 1000.1;
　　　　　　　　抽象方法：
　　　　　　　　public abstract void start();
　　　　　　　　public abstract void run();
　　　　　　　　public abstract void stop();
　　　　　　}
　　3) 简化接口格式：
　　　　interface 接口名{
　　　　　　常量：
　　　　　　数据类型 常量名 = 常量值;
　　　　　　抽象方法：
　　　　　　返回值类型 方法名(参数);
　　　　}
　　　　eg:
　　　　　　interface Car{
　　　　　　　　double MAX_PRICE = 2000000.1;
　　　　　　　　double MIN_PRICE = 1000.1;
　　　　　　　　void start();
　　　　　　　　void run();
　　　　　　　　void stop();
　　　　　　}
　　　　案例：Demo2

public class Demo2 {
  public static void main(String[] args) {
//	Car car = new Car();
//接口不是类，不能直接使用接口来创建对象
	Bmw bmw =
		new Bmw("宝马","12345678","黑色",
				  20000.1,"普通版");
	bmw.start();
	bmw.run();
	bmw.stop();
  }
}
interface Car{
//常量
  public static final
  			double MAX_PRICE=20000000.1;
  double MIN_PRICE = 20000.1;
//抽象方法
  public abstract void start();
  void run();
  void stop();
}
class Bmw implements Car{
//属性
  String name;
  String no;
  String color;
  int speed = 0;
  double price;
  String type;
//构造方法:name，no，color，price，type赋值
  Bmw(String name,String no,String color,
		  double price,String type){
	this.name = name;
	this.no = no;
	this.color = color;
	this.price = price;
	this.type = type;
  }
//方法
  @Override
  public void run() {
	System.out.println(name+"在行驶");
  }
  @Override
  public void start() {
	System.out.println(name+"启动了");
  }
  @Override
  public void stop() {
	System.out.println(name+"刹车了");
  }
}

public class Demo3 {
  public static void main(String[] args) {
	Midea midea =
		new Midea("美的","壁挂式",
				  2000.99,"蓝色",28);
	midea.show();
	midea.hot(5);
	midea.cool(9);
//接口名.常量名
	System.out.println(Kongtiao.MAX_PRICE);
	System.out.println(Kongtiao.MIN_PRICE);
//实现类名.常量名
	System.out.println(Midea.MAX_PRICE);
	System.out.println(Midea.MIN_PRICE);
//对象名.常量名
	System.out.println(midea.MAX_PRICE);
	System.out.println(midea.MIN_PRICE);
  }
}
interface Kongtiao{
//常量
  public static final
  			double MAX_PRICE=200000.11;
  double MIN_PRICE = 2000.99;
//抽象方法
  void show();
  public abstract void cool(int degree);
  public abstract void hot(int degree);
}
//设计Kongtiao接口
//常量：MAX_PRICE = 200000.11；
//     MIN_PRICE = 2000.99;
//抽象方法：void show():输出每一个属性的值
//void hot(int degree):升高degree度
//void cool(int degree):降低degree度
class Midea implements Kongtiao{
//属性：名称，类型，价格，颜色，温度
  String name;
  String type;
  double price;
  String color;
  int degree;
//构造方法：
  Midea(String name,String type,
		  double price,String color,
		  int degree){
	this.name = name;
	this.type = type;
	this.price = price;
	this.color = color;
	this.degree = degree;
  }
  @Override
  public void cool(int degree) {
	this.degree = this.degree - degree;
	System.out.println(name+"降低"+degree
		+"度以后，当前的温度是"+this.degree);
  }
  @Override
  public void hot(int degree) {
	this.degree = this.degree + degree;
	System.out.println(name+"升高"+degree
		+"度以后，当前的温度是"+this.degree);
  }
  @Override
  public void show() {
	System.out.println(name+","+type+
		","+price+","+color+","+degree);
  }
}

　　4）接口不是类，不能使用接口直接来创建对象。
　　5）实现类：编写一个类来实现接口，该类称为实现类，实现类必须要重写接口中所有的抽象方法，可以创建该实现类的对象。
　　6）访问常量：
　　　　a）接口名.常量名
　　　　b）实现类名.常量名
　　　　c）对象名.常量名
　　7）一个接口可以继承多个接口，但是该接口的实现类必须重写所有接口中，所有的抽象方法。接口之间可以多继承。
　　　　案例：Demo4

public class Demo4 {
  public static void main(String[] args) {
	Foo foo = new Foo();
	foo.f1();
	foo.f2();
	foo.f3();
	foo.f4();
  }
}
interface Foo1{
  void f1();
}
interface Foo2{
  void f2();
}
interface Foo3{
  void f3();
}
interface Foo4 extends Foo1,Foo2,Foo3{
//f1(),f2(),f3()
  void f4();
}
class Foo implements Foo4{
	@Override
	public void f4() {
		System.out.println("接口Foo4中方法");
	}
	@Override
	public void f1() {
		System.out.println("接口Foo1中方法");
	}
	@Override
	public void f2() {
		System.out.println("接口Foo2中方法");
	}
	@Override
	public void f3() {
		System.out.println("接口Foo3中方法");
	}
}

　　8）一个实现类可以实现多个接口，但是必须重写所有接口中所有的抽象方法。
　　　　案例：Demo5

public class Demo5 {
  public static void main(String[] args) {
	Koo koo = new Koo();
	koo.f1();
	koo.f2();
	koo.f3();
	koo.f4();
  }
}
interface Koo1{
  void f1();
}
interface Koo2{
  void f2();
}
interface Koo3{
  void f3();
}
interface Koo4{
  void f4();
}
class Koo implements Koo1,Koo2,Koo3,Koo4{
	@Override
	public void f1() {
		System.out.println("接口Koo1中方法");
	}
	@Override
	public void f2() {
		System.out.println("接口Koo2中方法");
	}
	@Override
	public void f3() {
		System.out.println("接口Koo3中方法");
	}
	@Override
	public void f4() {
		System.out.println("接口Koo4中方法");
	}
}

　　9）在接口中也可以使用父类声明指向子类对象。
　　　　接口名 对象名 = new 实现类构造方法
　　　　该类对象只能访问接口中声明（定义）方法。
　　　　案例：Demo6

public class Demo6 {
  public static void main(String[] args) {
//接口名 对象名 = new 实现类构造方法
	Eoo1 eoo = new Eoo();
	eoo.f1();
	eoo.f2();
//该类对象可以访问接口中定义的方法。
  }
}
interface Eoo1{
  void f1();
  void f2();
}
class Eoo implements Eoo1{
	@Override
	public void f1() {
	  System.out.println("接口Eoo1中方法f1");
	}
	@Override
	public void f2() {
	  System.out.println("接口Eoo1中方法f2");
	}
}

　　　　该类对象不能访问实现类单独编写的方法（不是重写接口中的方法）。
　　　　案例：Demo7

public class Demo7 {
  public static void main(String[] args) {
	Zoo1 zoo = new Zoo();
	zoo.f1();
//	zoo.f2();
//该类对象只能访问接口中定义的方法，不能访问实现类
//单独编写的方法。
  }
}
interface Zoo1{
  void f1();
}
class Zoo implements Zoo1{

	@Override
	public void f1() {
		System.out.println("接口Zoo1中方法");
	}
    public void f2(){
    	System.out.println("单独编写方法f2");
    }
}

　　10）接口跟抽象类之间区别
　　　　a）接口是一个特殊引用数据类型，主要用于设计。抽象类本质也是类，内部含有抽象方法而已。
　　　　b）接口由常量和抽象方法组成。抽象类可以由属性，构造方法，非抽象方法以及抽象方法组成。
　　　　c）接口之间可以多个继承，一个接口可以继承多个接口，但是该接口的实现类，必须要重写所有接口中所有的抽象方法（多继承）；一个实现类可以实现多个接口，但是必须重写所有接口中所有的抽象方法。抽象类本质也是一个类，永远是单继承。

3 访问控制修饰符
　　1）public :公共的，可以用来修饰类，属性，构造方法以及方法，被public修饰的类，属性，构造方法以及方法，可以任意进行访问。
　　2）private：私有的，可以用来修饰属性，构造方法以及方法，被private修饰的属性，构造方法以及方法，只能在本类的内部访问，外界无法访问。
　　3）默认：系统默认提供的访问控制修饰符，可以用来修饰类，属性，构造方法以及方法，被默认修饰的类，属性，构造方法以及方法，只能在本包内访问，不同包之间无法访问。
　　4）protected：受保护的，可以用修饰属性，构造方法以及方法，被protected修饰属性，构造方法以及方法，在本包内任意访问，不同包之间，子类可以访问父类中使用protected所修饰的部分。
　　案例：Demo8~Demo9

public class Demo8 {
  public static void main(String[] args) {
	User user = new User();
	System.out.println(user.name);
//被public修饰的属性外界可以任意的访问
//	System.out.println(user.age);
//被private修饰的属性只能在本类的内部访问，外界
//无法访问
	System.out.println(user.job);
//被默认修饰的属性本包内任意访问。
	System.out.println(user.salary);
//被protected修饰的属性本包内任意访问。
  }
}

4 Object

　　Object是Java中最根上的类，所有的类都是直接或者间接的继承Object
　　案例：Demo10

public class Demo10 {
  public static void main(String[] args) {
	Moo moo = new Moo();
	int num1 = moo.hashCode();
	System.out.println(num1);
	Moo moo2 = new Moo();
	int num2 = moo2.hashCode();
	System.out.println(num2);
  }
}
class Moo{//默认直接继承Object

}

　　hashCode():返回是一个int类型数字。
　　toString(): 返回当前对象的信息，返回结果是String类型的。默认返回值包名.类名@16进制数字。经常对toString()进行方法重写，返回属性信息。
　　案例：Demo11

public class Demo11 {
  public static void main(String[] args) {
	Person p1 =
		new Person("刘邦",36,
		200000.99,"长安","13555555555");
	String str = p1.toString();
//包名.类名@16进制数字
	System.out.println(str);
//com.tarena.demo.Person@4f1d0d
  }
}
class Person{
//属性：
  String name;
  int age;
  double salary;
  String address;
  String phone;
//构造方法：给每一个属性赋值
  Person(String name,int age,
		  double salary,String address,
		  String phone){
	this.name = name;
	this.age = age;
	this.salary = salary;
	this.address = address;
	this.phone = phone;
  }
  @Override
  public String toString() {
	String str = "该Person对象的name="+
	name+",age="+age+",salary="+salary
	+",address="+address+",phone="+
	phone;
	return str;
}
}

5 super
　　1）super(参数)：在子类构造方法第1行使用，调用父类中的构造方法。
　　2）super.属性名：访问被子类属性所覆盖的父类的属性。
　　　　案例：Demo12

public class Demo12 {
  public static void main(String[] args) {
	Noo2 noo = new Noo2();
	System.out.println(noo.name);
	noo.showSuperName();
  }
}
class Noo1{
  String name = "刘彻";
}
class Noo2 extends Noo1{
  String name = "刘病已";
//super.属性名：访问被覆盖的父类的属性
  void showSuperName(){
	System.out.println(super.name);
  }
}

　　3）super.方法名(参数)：访问被子类重写的父类中的方法。
　　　　案例：Demo13

public class Demo13 {
  public static void main(String[] args) {
	Coo2 coo = new Coo2();
	coo.f1();
	coo.showSuperF1();
  }
}
class Coo1{
  void f1(){
	System.out.println("父类Coo1中编写f1()");
  }
}
class Coo2 extends Coo1{
  void f1(){
	System.out.println("子类Coo2重写父类" +
			"Coo1中的方法f1()");
  }
//super.方法名(参数)：访问被子类重写的父类中的方法
  void showSuperF1(){
	super.f1();
  }
}