Java面向对象（二）

一、引用

引用方式：
值传递--基本类型作为参数传递
引用传递——引用类型作为参数传递
        由于引用类型只开辟了一块地址函数内外的参数共用一块地址
        形参的值的改变会影响实参的值、
确定是值传递还是引用传递，要看调用函数时括号里是基本类型还是引用类型

public class cite1 {
   
    public static void main(String[] args) {
        int a  =10;
        cite1 test1=new cite1();
        test1.test(a);//20 实参传进去 填充形参
        System.out.println("a="+a);//10 输出实参
    }
    public void test(int b){
        b=20;
        System.out.println("b="+b);//20
    }
}

二、this关键字

this关键字：

    public class Person {
    String name;
    int age;
    String gender;

    public Person(String name,int age,String gender){
        this.name=name;
        this.age=age;
        this.gender=gender;
    }

    this表示当前正在使用对象的构造方法

    public Person(){
        this(null,0,null);
    }

    this表示当前正在使用对象的成员变量
    public void showInfo(){
        System.out.println("姓名："+name+"年龄："+age+"性别："+gender);
        this.work();
    }

    this也可以表示调用当前使用对象的成员方法

    public void work(){
        System.out.println(name+"正在工作");
    }
}

三、代码块

代码块是在类声明中一段没有名字的代码。其分为静态代码块和实例代码块两种。

实例代码块的格式是

{

}

特点是在创建时不需要显示的调用就可以执行

静态代码块的格式是

static{

}

其特点是在类被加载时就会执行。

package com.wbc.opp.oop.day2.codeBlock;

public class codeBlockDemo1 {
    
    {
        System.out.println("我是实例代码块，在创建时，不需要显示的调用，可以直接执行");
    }
    static{
        System.out.println("我是静态代码块，在类被加载时就会执行");
    }

    /*public static void main(String[] args) {
        //静态代码块会加载
    }*/
    static int a;

}

package com.wbc.opp.oop.day2.codeBlock;

public class testDemo1 {

    public static void main(String[] args) {
//        new codeBlockDemo1();
        System.out.println(codeBlockDemo1.a);
    }
}

四、static静态

static被称为静态，可以用于修饰类的成员变量，成员方法，代码块，内部类
静态成员不依赖于类的实例（对象），被类的所有实例共享
static修饰的方法、变量不需要要依赖于对象来进行访问，只要这个类被加载，静态成员
就会被加载创建
特点:
• 随着类的加载而加载
• 优先于对象存在
• 修饰的成员，被所有对象所共享
• 可不创建对象，直接使用类名调用

public class Chinese{
String name ;//姓名
static String country=”中国”;//国家
｝

静态属性是类的所有对象共享的，即不管创建了多少个对象，静态属性在内存中
只有一个

可以通过类名.静态变量直接访问，也可以通过对象.静态变量的方式访问（但
是更推荐使用类名.静态变量的方式）。

//静态的成员在类被创建时就创建了，不需要创建对象

静态的成员变量对应静态的成员方法
非静态对应非静态

    //静态的方法只能使用静态的成员变量，因为他们都是随着类的加载而加载的
    //与非静态成员变量没有关系的，每次入参去完成固定功能的，适合定义静态变量
    //一般功能类的类都定义为静态的

静态的方法是否能使用this关键字呢？-》不能，静态方法与对象随着类的加载就加载了，与对象无关
静态方法不可以用this，也不能用super

静态成员变量与非静态成员变量的区别

       静态成员变量相较于非静态成员变量，不依赖类的实例也就是对象，被类的所有实例共享（静态成员变量开辟的内存只有一份，每一个对象对应的访问静态成员变量使其值改变时，其内存的值也就改变）。当类加载的时候， 静态成员变量就会加载，并且可以不创建对象，可以直接使用类名调用。静态成员变量能对应静态成员方法， 因为静态成员变量与静态方法都是随着类的加载而加载的，也可以对应非静态成员方法。而非静态成员变量只 能对应非静态成员方法。静态成员变量不能使用this和super关键字，而非静态成员变量可以。

package com.wbc.opp.oop.day2.staticDemo;

public class Chinese {
    String name;//中国人每人都需要有自己的属性

    static String country = "China";//静态属性在内存中只有1份

    //使用一个变量记录此类被创建了多少个对象
    static int count=0;
    public Chinese(){
        count+=1;
    }

    //静态的方法只能使用静态的成员变量，因为他们都是随着类的加载而加载的
    //与非静态成员变量没有关系的，每次入参去完成固定功能的，适合定义静态变量
    //一般功能类的类都定义为静态的
    public static void printCount(){
        System.out.println("共创建了"+count+"个对象");
    }

    public void eat(){
        System.out.println(name+"吃饭");
        System.out.println(count);//非静态的方法可以使用非静态的变量
    }


}

package com.wbc.opp.oop.day2.staticDemo;

public class testChinese {
    public static void main(String[] args) {

        //静态的成员在类被创建时就创建了，不需要创建对象
        System.out.println(Chinese.country);

        Chinese c1 =new Chinese();
        c1.name="张三";
        Chinese c2=new Chinese();
        c2.name="李四";
        c1.country="中国";
        c2.country="中国人";
        System.out.println(c1.country);//中国人
        System.out.println(c1.country);//中国人
        //static属性的成员变量，所有对象共用一份，减少了占用空间

        //在访问时，建议使用类名访问
        //静态的成员在类被创建时就创建了，不需要创建对象
        System.out.println(Chinese.country);

        //对象计数器
        Chinese.printCount();
    }
}

五、包

包： 产生问题：类的数量变多，会出现同名类，需要按照不同的功能分类
    解决问题：提出包的概念，用来管理类
    包的又一重要功能，权限访问

    第一级 指该项目的类型，如com,org,gov等，
    第二级 指项目所开发或者运行的公司名称，如：oracle,sun,huawei等
    第三级 指项目的名称，如：bcms,oa,erp,cms等
    第四级 指项目模块的名称，如：bean,action,exception

六、import

关键字 import 当在一个类中使用了另一个包中的类，使用前必须使用import关键字调用
使用本包中的类，以及java.long包中的类，不需要导入
import在导入时只能导入相同的一个类名
可以使用全命名 new 包名.包名.。。。.类名

七、访问修饰符

访问修饰符共有四种，由大到小分别是：

public 公共权限，用来修饰类，成员方法，成员变量，内部类。 public 修饰的成员可以访问到本 类，本包其他类，其他包。

protected 受保护权限，修饰成员变量，成员方法，内部类。 protected 修饰的成员可以访问到本 类，本包不同包的子类（通过extends继承父类的子类）。

默认权限（什么都不写）修饰类，成员变量，成员方法，内部类。默认权限 修饰的成员可以访问到本 类，本包。

private 私有权限，修饰成员变量，成员方法，内部类。 private 修饰的成员可以访问到本类。

package com.wbc.opp.oop.day2.accessDemo;

public class Animal {
    public String proname0;//公共权限修饰的成员在任何地方都可以访问到
    protected String proname1;//受保护权限 在本类以及同包的其他类中可以访问
    String proname2;//默认权限 在本类以及同包的其他类中可以访问
    private String proname3;//私有权限 只能本类使用

    public void pubtest(){
        Animal animal=new Animal();
        animal.proname0="aaa";
        animal.proname1="bbb";
        animal.proname2="ccc";
        animal.proname3="ddd";
    }
    //公共 受保护 默认 私有都可以修饰内部类
}

八、课后练习

1、

package com.wbc.opp.oop.homework.day2;


/*设计一个简单的计算器类
可以对两位整数(int类型)进行的加、减、乘、除运算,并返回运算结果
在main方法中调用测试*/

public class Calculators {
    public static int add(int a,int b){
        return a+b;
    }
    public static int subtract(int a,int b){
        return a-b;
    }
    public static int multiply(int a,int b){
        return a*b;
    }
    public static int divide(int a,int b){
        return a/b;
    }

    public static void main(String[] args) {
        int a=Calculators.add(1,1);
        System.out.println(a);
        int b=Calculators.subtract(1,1);
        System.out.println(b);
        int c=Calculators.multiply(1,2);
        System.out.println(c);
        int d=Calculators.divide(2,2);
        System.out.println(d);
    }
}

2、

package com.wbc.opp.oop.homework.day2.Account;

/*声明一个银行账户类Account

成员变量：利率、账号、余额，其中所有账户的利率是相同的

提供有参构造public Account(String account,double balance)

提供计算年利息方法public double annualInterest()，余额*利率

在测试类的main中，创建账户类的两个对象，账号分别为“11111”和“22222”，余额分别为“1000和2000”元，
利率值是0.035，调用方法计算两个账号的利息。*/


public class Account {
    static double interestRate;//利率
    String nameNum;
    double money;
    public Account(){

    }
    public Account(String nameNum,double money,double interestRate){
        this.nameNum=nameNum;
        this.money=money;
        this.interestRate=interestRate;
    }

    public double annualInterest(){
        return this.money*this.interestRate;
    }
}

package com.wbc.opp.oop.homework.day2.Account;

public class TestAccount {
    public static void main(String[] args) {
        Account peo1=new Account("11111",1000,0.035);
        Account peo2=new Account("22222",2000,0.035);
        double interest1=peo1.annualInterest();
        System.out.println(peo1.nameNum+"的利息为"+interest1);
        double interest2=peo2.annualInterest();
        System.out.println(peo2.nameNum+"的利息为"+interest2);
    }
}

3、

.声明一个图形工具类GraphicTools，包含两个重载方法

方法1：public double getArea(double base, double height),根据底边和高，求三角形面积，

方法2：public double getArea(double a, double b, double c),根据三条边，求三角形面积，根据三角形三边求面积的海伦公式：

1. 在测试类的main方法中调用(求平方根使用Math类中的sqrt方法,用法Math.sqrt(值))

package com.wbc.opp.oop.homework.day2.GraphicTools;

public class GraphicTools {

    public static boolean check(double a,double b,double c){
        if((a+b)>c||(a+c)>b||(b+c)>a){
            return true;
        }
        else
            return false;
    }

    public static double getArea(double base, double height){
        return (base*height)/2;
    }

    public static double getArea(double a, double b, double c){
        double p=0;
        if(check(a,b,c)){
            p=(a+b+c)/2;
        }

        return Math.sqrt(p*(p-a)*(p-b)*(p-c));
    }
}

package com.wbc.opp.oop.homework.day2.GraphicTools;

public class TestGraphicTools {
    public static void main(String[] args) {
        System.out.println(GraphicTools.getArea(3,4,5));
        System.out.println(GraphicTools.getArea(3,4));
    }
}