前情提要
摆烂好久，今天老师说要学好Java和数据库，我！卷土重来！
重开个笔记，承接一下上一个笔记，到类的构造和置取，说了一下this
~面向对象有三大特征，封装，继承和多态。封装是通过方法访问内部信息。具体的实现细节没有必要显示，类的一些属性可以通过置取方法来显示。数据
完整性安全性
，类的
封装性和独立性
~置取方法：性别属性
~参数传递：基本类型传递变量的值，引用类型传递引用地址。值传递java
~数据类型
//第九章的小例子：设计一个方法getDistance()求两点间距离
public class e1{
private double x;
private double y;
public e1(double x,double y)
{
this.x=x;
this.y=y;
}
public void setX(double x)
{
this.x=x;
}
public void setY(double y)
{
this.y=y;
}
public double getDistance (e1 p)
{
return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
}
public static void main(String[]args)
{
e1 p1=new e1(0,0);
e1 p2=new e1(3,4);
System.out.println(p1.getDistance(p2));
p2.setX(6);
p2.setY(8);
System.out.println(p1.getDistance(p2));
}
}
/*5.0
10.0*/之前的搞的有点乱，还是按章节来梳理，第十章开始。
第十章：类的组合关系
类间关系：关联关系，依赖关系和泛化关系。这里讲关联关系中的类的组合。
最常见形式：一个类作为另一个类的属性。提高代码复用性，一致性
举一个题目说明：
一辆Car有(has)四个轮子(Wheels)和一个发动机(Engine)。现在要求用组合方法设计类Car、类Wheel和类Engine.
(1)
类Engine
(2)
类Wheel
(3)
类Car
(4)
类Test
这四个类都装在一个包f2中
package f2;
/*有字符串属性model记录轿车的型号，
有属性wheels[]和engine，
分别是Wheel类对象数组和Engine类对象
有构造方法，参数是三个字符串，分别表示轿车的型号、轮胎型号和发动机的型号，
有方法changeWheel()可以改变指定轮胎的型号，
有方法start()，先输出下面样例中包含轿车型号和“firing”的字符串，然后调用engine的start()，再调用所有轮胎的roll()，最后显示轿车型号和“running”。
*/
class car {
String model;
Wheel[] Wheels = new Wheel[4];//实例化数组
Engine engine=new Engine();//实例化Engine
public car(String model, String Wheelstype, String engine) {
this.model = model;
for(int i=0;i<4;i++)
{
Wheels[i]=new Wheel(i+1,Wheelstype);
}//实例化数组成员
this.engine.type = engine;
}
void changeWheel(int a, String type) {
Wheels[a - 1].type = type;
}
void start() {
System.out.println(model + " firing");
engine.start();
for (int i = 0; i < 4; i++) {
Wheels[i].roll();
}
}
}
package f2;
/*有字符串属性type记录发动机的型号，
有构造方法，可设置发动机的型号
有方法start()启动引擎(输出下面样例中包含发动机型号和“starts”的字符串)*/
class Engine {
String type;
Engine()
{
}
Engine(String type) {
this.type = type;
}
void start() {
System.out.println(type + " starts");
}
}package f2;
/*有字符串属性type记录轮胎的型号
有整数类型属性index记录当前轮胎编号
(1:front-left，2:front-right，3:back-left，4:back-right)，
有构造方法，可设置轮胎的型号和编号
有方法roll()表示轮胎正在转动
(输出下面样例中包含轮胎型号、轮胎位置和“rolling”的字符串)*/
public class Wheel {
String type;
int index;
public Wheel()
{
}
public Wheel(int a, String b) {
type = b;
index = a;
}
public void roll() {
switch (index) {
case 1:
System.out.println(type + " front-left" + "rolling");
break;
case 2:
System.out.println(type + " front-right" + "rolling");
break;
case 3:
System.out.println(type + " back-left" + "rolling");
break;
case 4:
System.out.println(type + " back-right" + "rolling");
break;
default:
System.out.println("error\n");
break;
}
}package f2;
public class Test
{
public static void main(String[] args)
{
String wheel="BridgeStone";
String model="BMW";
String engine="Mode L";
Car car1=new Car(model,wheel,engine);
car1.start();
System.out.println("=================");
model="Benz";
engine="Model S";
Car car2=new Car(model,wheel,engine);
car2.changeWheel(2,"Michelin");
car2.start();
}
}
第十一章：类方法重载
一个类多个名字相同，参数的个数或者类型不同的构造方法，就是重载的构造方法。调用时找的是最匹配的那个方法。
引用类型指向实例，所以对象的复制不能图方便用=。
1.clone()
2.org.apache.commons中的BeanUtils,PropertyUtils
3.序列化实现
第十二章：静态
private static int counter =0;
public Student(int x,int y)
{
this.x=x;this.y=y;
counter++;
}
public static int getCounter()
{
return counter;
}
//如果要访问静态方法，使用类名访问
Student.getCounter();静态属性和静态方法称为类属性和类方法。
非静态属性和非静态方法称为实例属性和实例方法。
第十三章：泛化
所谓泛化，就是把很多类方法中一样的部分，搞出来搞成一个模板，通过继承的方式来使用这个模板，减少重复。
public class Test{
public static void main(String [] args){
Teacher t = new Teacher("zhang", 45, 1886);
Worker w = new Worker ("wang", 42, 1550,2);
t.display();
w.display();
}
}
abstract class Person{
private String name;
private int age;
public Person(String name, int age){
this.name = name;
this.age = age;
}
public abstract void display();
}
class Teacher extends Person{
private double salary;
public Teacher(String name, int age, double salary){
super(name, age);
this.salary = salary;
}
public void display()
{
System.out.println("My salary is " + salary);
}
}
class Worker extends Person{
private double salary;
private int level;
public Worker(String name,int age,double salary,int level){
super(name,age);
this.salary=salary;
this.level=level;
}
public void display(){
System.out.println("My level is " + level);
}
}public class Test{
public static void main(String [] args){
Teacher t = new Teacher(“zhang”, 45, 1886);
Worker w = new Worker (“wang”, 42, 1550,2);
t.display();
w.display();
}
}
abstract
class Person{
private String name;
private int age;public Person(String name, int age){
this.name = name;
this.age = age;
}
public
abstract
void display();
}
class Teacher
extends
Person{
private double salary;
public Teacher(String name, int age, double salary){
super(name, age);
this.salary = salary;
}
public void display()
{
System.out.println(“My salary is ” + salary);
}
}
class Worker extends Person{
private double salary;
private int level;
public Worker(String name,int age,double salary,int level){
super(name,age);
this.salary=salary;
this.level=level;
}
public void display()
{
System.out.println(“My level is ” + level);
}
}