初学java新世界（2）

鹤早早

已于 2022-10-26 20:53:02 修改

阅读量635

点赞数 1

分类专栏：在校学习/(ㄒoㄒ)/~~ 文章标签： 1024程序员节 java

于 2022-10-25 16:11:17 首次发布

本文链接：https://blog.csdn.net/qq_32765617/article/details/127501443

版权

在校学习/(ㄒoㄒ)/~~ 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

前情提要

摆烂好久，今天老师说要学好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);
        }
}