JAVA学习总结（三）

1.什么是是类？

1.1.具有相同特征和行为的一组对象的抽象称为类。

1.2.描述类时要描述：
　　特征：属性，名词，数据。
　　行为：方法，动词，对数据进行操作的代码块。

 

1.3.定义类，就是设计模板根据模板生产产品，根据类实例对象程序就是对对象的操作。

2.如何定义类 ?

//例如：
    修饰符 class 类名{
        //构造器
        修饰符 构造器名(参数列表){
            初始化代码;
        }
        public 类名(){
            //初始化对象
            num = 10;
            name="无名氏";
            arr = new float[]{10,20.5,6,7.8};
        }
        public 类名(int num, String name, float[] arr){
            //初始化对象
            init(num, name, arr);
            或
            this.init(num, name, arr);
        }
        }    

 

类中的属性定义

/*
修饰符 类型　属性名;
    或
修饰符 类型　属性名=值;
*/
　　private int num=0;
　　private String name;
　　private float[] arr;

属性的作用：

　　1.用于保存对象的状态值，在声明属性时可以显示或隐式的赋初始值。

　　2.如果没有显式赋初始值，所有属性都有默认值，规则：int byte short long float double都默认为0，boolean默认为false，char编码0，其他引用类型默认为null。

　　属性在外部调用：对象.属性名（私有化不能访问，公共化可以）
　　属性在内部调用：this.属性名或直接属性名（当属性名与局部变量有命名冲突时，属性表示为this.属性名，如果没有前缀就是指局部变量）

　　注意：在类中定义的属性，实例化成对象后，每个同类型的对象都有相同的属性作为对象数据成员

类中的方法定义

/*
修饰符 类型　方法名(参数列表){
        方法的实现代码
}
*/
public String toString(){
        return ...;
}
private void init(int num, String str, float[] arr){
        初始化代码;
    }

方法的作用：

1.用于描述对象的行为，是外部访问接口，由两个部分构造：
　　声明和实现
　　public String toString（）//声明部分
　　//实现部分
　　{
　　　　return...；
　　}
2.在外部调用：对象.方法名（）；（私有化不能访问，公共化可以）。
3.在内部调用：this.方法名（）或方法名（）。

private 是私有的，只能在类的内部访问。
public 是公共的，其他类都可以访问。

3.如何访问对象的属性（读和写），调用方法？

/*
使用"."运算符
类名 p1 = new 类名();
为p1引用的对象设置一个name属性，值为“张三”，性别，身高。
*/
p1.name = "张三"；
p1.sex = "男"；
p1.height = 160;

//用方法访问：
p1.setName("张三")；
p1.setSex("男");
p1.setHeight("160");

//打印信息；
P1.print();

什么是对象？ 类的实例。

对象是类的实例，类是对象的抽象，new实例化对象关键字。

new 构造器（）；//生成一个对象，实例化

new关键字创建对象，在内存开辟了空间，并初始化数据

 

4.构造器：　

1.每个类都有构造器，与类名同名。
2.当类没有显式声明构造器，就会有一个默认构造器。

//例如：
    new String（）;//String（）是String类的构造器

相同类型的对象：有相同属性和方法，属性值不同.

构造器（构造方法）的作用：

　　1.用于实例化对象，初始化对象，只能使用new关键字调用；
　　　new 构造器（）；
　　2.注意：构造器名称必须与类名同名，构造器没有返回类型。

 

5.关于访问修饰符：

　　　　　　　　　　　　类的内部　　 同包的类 　　子类　　     不同包非子类

public 　　　  　 公共的　　        允许       　　　 允许 　　　　 允许 　　　　　　   允许
protected 　　　受保护的 　　　 允许　　　　    允许 　　　　 允许 　　　　 　　  不允许
默认 　　　　　　　　　　　　   允许 　　　　   允许 　　    　不允许（不同包）　 不允许
private 　　　　 私有的 　　　　 允许 　　　　 不允许　　　　 不允许 　　　　　   不允许

1.对于类class来说，只能使用public或默认访问修饰符（内部类除外）。

2.什么是内部类？ 在一个类的内部嵌套定义的类。

//内部类
//例如：
class ClassA{
    //内部类
    class ClassB{
        
    }
}

类的修饰符：只能使用public或默认访问修饰符（内部类除外）或abstract 抽象的 | final 终态。

构造器的修饰符：public|protected|默认|private
属性的修饰符：public|protected|默认|private
方法的修饰符：public|protected|默认|private

//例如修饰属性：
    public  int a;//公共属性
    protected int b;//受保护的属性
    int c ;//默认权限属性
    private int d;//私有的属性

包：定义类的域名

　　package 打包用的关键字：

　　　　一个类文件只能使用一次，并且必须是代码中的第一行（除注释以外）。

　　import 导入包的关键字：
　　　　一个类文件可以多次使用import，使用的顺序。
　　　　一个类文件可以同时定义多个类，但只能有一个public类，其他只能默认权限的类。

例如：

　　package..
　　import...
　　import...
　　.....
　　public class A{
　　　　...
　　}
　　class B{

　　}
　　class C{
　　}

 

6.修饰符：

static 静态的。可以修饰：属性，方法，代码块，不能修饰构造器.

1.静态属性、方法调用方法：类名.属性|对象.属性，可称为类成员。
2.非静态属性、方法调用方法：对象.属性，可称为对象成员。

3.静态属性时所用对象的共享变量。

4.类的静态属性，在类创建对象时。

5.静态代码块仅执行一次，在类加载后第一个执行。
　　static{
　　　　代码块..
　　}

6.非静态代码块实例化对象一次执行一次，在创建对象之前（new 构造器（））时执行。

 

7.重载（overload）

　　1.什么是重载：

　　　　名称相同，参数不同（个数不同，类型不同，类型且顺序不同），重载应用范围：方法，构造器。

//例如:
    //f1()重载，个数不同
    void f1（int x）{}
    void f1(int x,int y){}
    //
    
    //f1()重载,个数不同
    void f1(int x){}
    void f1(int x, int y){}
    //f2()重载,类型不同
    void f2(int x){}
    void f2(float x){}
    //f3()重载,顺序不同
    void f3(int x, String str){ x+str;}
    void f3(String str, int x){ x+str+"\n";}
    
    
    //f4()不是重载,顺序不同,出错
    int f4(int x, int y){ return x+y;}
    int f4(int y, int x){ return x*y;}    
    调用f4(10,20)执行哪一个方法?调用时不明确
    
    //f5()重载
    void f5(){ }
    void f5(String str, int x){ }
    void f5(int x, float y, String str){ }

 

　　2.重载的好处:　　　　

　　　　1.同一个方法可执行不同的代码,根据参数不同自动选择。
　　　　2.一个访问接口，多个实现方法。
　　　　3.实现多态调用。

class Driver{
        void driv(宝马  car){ ... }
        void driv(奔驰  car){ ... }
        void driv(奥迪  car){ ... }
    }

 

8. 继承(extends)

一个子类只能拥有一个父类，所以 extends 只能继承一个类。

1.如何使用?

class A{
    int x;
    
    public void setX(int x){this.x = x;}
    public int getX(){return x;}
    public String toString(){return "A类的实例,x属性的值是:"+x;}
    
    public A(){x=10;}
    public A(int x){this.x = x;}
}
//B类继承A类,A类是B类的父类(superClass,BaseClass)
//B类是A类的子类（派生类,subClass, childClass）
class B extends A{
    int y;
    public void setX(int x){this.x = x;}
    public int getX(){return x;}
}

1.如果要显式调用父类指定构造器，使用super（[参数]）;来调用。

2.super（）必须注意：在构造器中只能是第一行代码，只能使用一次。

3.子类继承父类所有属性和方法，构造器不能被继承但new子类对象时，总是先new父类对象。

4.默认调用父类的无参构造器。

5.继承的好处：

　　1.代码复用。
　　2.子类可以扩展新的属性和方法。

 

9.super 与 this 关键字：

　super关键字: 1.我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

　　　　　　　　    2.若要在子类调用父类的方法，需使用关键字super。

　　　　　　　　　3.super.属性或super.方法（）表示引用父类的对象的属性或方法。

 

　this关键字:　  1.this（参数列表）表示当前类的构造器，super（）表示父类的构造器。

　　　　　　　　　2.this.属性或this.方法（）表示引用当前类的对象的属性或方法。

 

10.final关键字　

final　最终的　关键字：

修饰符,可以修饰类，属性，方法,不能修饰构造器。

public final class A{//修饰类,终态类:不能作为父类，不能有子类
int x;
final int y;//修饰属性：只能赋一次值,不能修改
public static final int Z=10;//一般用法，表示常量

void fun1(){}
final void fun2(){}//修饰方法:子类不能重写该方法
}

常量：声明常量使用三个修饰符:public static final,常量名全部大写,有别于变量名。
常量的访问方法:类名.常量名,例如:A.Z

 

11.abstract 关键字

abstract    抽象的　关键字：

修饰符,可以修饰类，方法，不能修饰属性，构造器。

abstract 与 final不能同时并存。

public abstract class A{//修饰类:抽象类,不能实例化对象,但可以有构造器.
        void fun1(){
            //有方法体，有实现
        }
        
        abstract void fun2();
        //修饰方法:抽象方法，不能有代码的实现部
    }

抽象类:

　　1.不能实例化对象，也就是不能new对象。

　　2.抽象类中可以有具体方法，也可以包含抽象方法。

　　3.如果一个类中有抽象方法，这个类必须是抽象类。
　　4.抽象类一般作为父类。

 

java程序设计四大原则:　

　　1.开闭原则:源代码开放，对修改关闭。
　　2.单一职则:业务逻辑与业务实体数据分离。　
　　3.里氏替换:参数能用父类不用子类。

 

一个模拟计算器的实例：

public abstract class calc{
    private double num1, num2,rs;
    private String op;
    
    public void setNum1(double num1){
        this.num1 = num1;
    }
    public double getNum1(){
        return num1;
    }
    
    public void setNum2(double num2){
        this.num2 = num2;
    }
    public double getNum2(){
        return num2;
    }
    
    public void setOp(String op){
        this.op = op;
    }
    public String getOp(){
        return op;
    }
    
    protected void setRs(double rs){
        this.rs = rs;
    }
    public double getRs(){
        return rs;
    }
    
    public abstract void exec();//计算的抽象方法
}

//加法器
public class Add extends calc{
    @Override
    public void exec(){
        double rs =getNum1()+getNum2();
        setRs(rs);
    }
}

//减法器
public class Diff extends calc{
    @Override
    public void exec(){
        double rs =getNum1()-getNum2();
        setRs(rs);
    }
}

//乘法器
public class Mul extends calc{
    @Override
    public void exec(){
        double rs =getNum1()*getNum2();
        setRs(rs);
    }
}

//除法器
public  class chuf extends calc {
    public void exec(){
        double rs =getNum1()/getNum2();
        setRs(rs);
    }
}

//计算器的业务逻辑类
public class ClacBo{
    public static calc getCalc(String op){
        calc c = null;
        if(op.equals("+"))
            c = new Add();
        else if(op.equals("-"))
            c = new Diff();
        else if(op.equals("*"))
            c = new Mul();
        else if(op.equals("/"))
            c = new chuf();
        return c;
    }
}

import java.util.*;
//Main
public class App{
    public static void main(String[] args){
        Scanner kb = new Scanner(System.in);
        System.out.print("请输入第一个操作数:");
        double num1 = kb.nextDouble();
        System.out.print("请输入一个运算符:");
        String op = kb.next();
        System.out.print("请输入第二个操作数:");
        double num2 = kb.nextDouble();
        
        calc c = ClacBo.getCalc(op);
        
        c.setNum1(num1);
        c.setNum2(num2);
        c.setOp(op);
        c.exec();
        
        System.out.println("结果是:"+c.getRs());
    }
}