Java笔记(三) 面向对象编程

最新推荐文章于 2020-06-11 15:22:34 发布

qq_39364730

最新推荐文章于 2020-06-11 15:22:34 发布

阅读量255

点赞数

分类专栏： Jaca笔记01

本文链接：https://blog.csdn.net/qq_39364730/article/details/76275040

版权

Jaca笔记01 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.对象属于某一个类,比如麻雀这个对象属于鸟类,不能说类属于某一个对象.

7.1 面向对象概述

1.对象的创建

Java语言中使用new 操作符调用构造方法就可以创建一个对象.

//看一个例子
//创建一个Test对象

Test test = new Test();
Test test = new Test("a");

先用类声明一个对象,然后让它等于new Test构造方法;而这个构造方法可以有参数,也可以没有参数

String str = "abc";
有一个特例String类,它可以不用new就能创建出一个对象,其实str也是一个对象,单Java虚拟机在创建字符串的同事,也创建了一个匿名的字符串对象,并交给str引用.

2.对象的引用

这里写图片描述
当用户使用new操作符创建一个对象后,可以使用”对象.类成员”来获取对象的属性和行为.对象的属性和行为在类中是通过类成员变量和成员方法的形式来表示的,所以当对象实例化之后,也就获得了相应的属性和行为

public class TransferProperty {
    int i = 47;//成员变量
    public void call() {//成员方法
        System.out.println("调用call方法");
        for (int i = 0; i < 3; i++) {//成员的方法调用了成员的变量i
            System.out.print(i+" ");
        }
        System.out.println();
    }

    //这里实现了利用对象来调用类的成员
    public static void main(String[] args) {
        //创建TransferProperty类的两个对象叫t1,t2吧
        TransferProperty t1 = new TransferProperty();
        TransferProperty t2 = new TransferProperty();

        t2.i =60;//给类的成员赋值
        System.out.println("第一次实例对象调用i的结果"+t1.i);
        t1.call();//使用成员方法

        System.out.println("第二次实例对象调用i的结果"+t1.i);
        t2.call();
    }

}

7.1.2 类

1.成员变量就是Java中类的属性.
成员变量不赋初值不会报错.

public class Bird{
    String wing;//翅膀
    String claw;//爪子

}

2.成员方法就是Java类中的行为

public class LeoPard{
    //凝视,目标是taget
    public void gaze(String target){}
    public void run{}

}

3.局部变量
如果在成员方法内定义一个变量,那么这个变量被称为局部变量.

public String getName(){
    int id = 0;//局部变量
    return id + this.name;
}

局部变量是在方法被执行是创建,在方法执行结束时被销毁.
在使用时必须进行复制操作或被初始化,否则会出现编译错误.The local variable id may not have been initialized本地的局部变量id没有被初始化.

4.局部变量的有效范围
可以将局部变量的有效范围称为变量的做用户,局部变量的有效范围从该变量的声明开始到该变量的结束为止.

5.this关键字
Java提供了this关键字,this代表类本身的对象.
这里写图片描述
所以this可以调用有残无参构造方法

public class AnyThing{
    public AnyThing(){//定义无参构造
    this("调用有参构造方法");
    System.out.println("无参构造方法被调用");
    }

    public AnyThing(String name){
    System.out.println("有参构造方法被调用");
    System.out.println(name);
    }
}

6.权限修饰符
这里写图片描述

7.3 类的构造方法

1.什么是构造方法
构造方法是一个与类同名的方法,对象的创建就是通过构造方法完成的.每当类实例化一个对象时,类都会自动调用构造方法.

public class Bird{
    public Bird(){}//Bird的类的构造方法
}
//构造方法,就是创建类的对象过程中运行的方法,也就是对象的初始化方法.

2.构造方法是给对象初始化的
在构造方法中可以为成员变量赋值,这样当实例化一个本类的对象时,相应的成员变量也将被初始化.如果类中没有明确定义构造方法,则编译器会自动创建一个不带参数的默认构造方法.

public class ClassTest{
    public ClassTest(){
    }
    public static void main(){
        ClassTest test = new ClassTest();//这里的ClassTest其实就是上面的public ClassTest(){}.如果不写这个构造方法,则自动生成一个默认无参构造方法.
    }
}

使用this关键字

this可以调用类的成员变量和成员方法,事实上this还可以调用类中的构造方法.

这里写图片描述

package LeiHeDuiXiang;

public class EggCake {
    int eggCount ;

    public EggCake(int eggCount) {//有参构造
        this.eggCount = eggCount;
        System.out.println("这个饼里有"+eggCount+"鸡蛋");
    }

    public EggCake() {
        this(1);
    }

    public static void main(String[] args) {
        EggCake e = new EggCake();
        EggCake e2 = new EggCake(5);
    }

}

使用私有构造方法

构造方法同其他方法一样,也可以使用private修饰,私有构造方法无法再本类外部使用,也就导致本类无法用new实例化,这样可以控制对象的生成.
这里写图片描述

7.4 静态变量,常量和方法

由static修饰额变量,常量,和方法被称作静态变量,静态常量,静态方法,他们都存放在内存的”静态区”中,这些变量和方法有独立的生存周期.
内存中的静态区在整个程序结束之后才会释放,所以静态修饰符修饰的代码生命周期是整个程序的生命周期

内存中静态区的变量可以被本类共享,其他类调用本类静态变量或静态方法时,无需实例化就可以被调用..

(1.)静态变量
很多时候,不同的类之间需要对同一个变量进行操作,比如一个水池,同事打开入水口和放水口,进水和出水这两个动作就会同时影响到池中的水量,此时池中的水量可以认为是一个共享的变量.在Java程序中,我们把共享的变量用static修饰,该变量就是静态变量.

//实例
public class Pool{
    static public int water = 0;
    public void outlet(){};
    public void inlet(){};
}
System.out.println("----------------");

public class Pool {
    public static int water = 0;

    public void outlet(){//防水的方法
        //如果水池中有水才进行放水,所以要进行一个判断
        if(water >= 2) {
            water = water -2;
        }else {
            water = 0;//没有2全放完
        }

    }
    public void inlet(){
        water = water +3;
    }
    //开始模拟场景
    public static void main(String[] args) {
        Pool in = new Pool();//构造进水对象
        Pool out = new Pool();//构造出水对象
        System.out.println("水池的水量"+Pool.water);
        in.inlet();//进水一次
        in.inlet();//进水两次
        System.out.println("水池的水量"+Pool.water);

        System.out.println("水池放水一次");
        out.outlet();
        System.out.println("水池的水量"+Pool.water);
    }


}

这里缺一张静态变量在栈内存的内存图

(2.)静态常量
用final static修饰一个成员变量,这个成员变量就会变成一个静态常量.
下面代码是静态常量的使用方法

package LeiHeDuiXiang;

public class Graphical {
    final static double PI = 3.1415926;

    public static void main(String[] args) {
        Circular c = new Circular(3.0);
        Shoerical v= new Shoerical(3.0);

    }
}

class Circular{
    double radius;//半径
    double area;
    public Circular(double radius) {//传一个半径
        this.radius=radius;
        area = Graphical.PI*radius*radius;
        System.out.println("圆的半径"+radius);
        System.out.println("圆的面积"+area);
    }
}

class Shoerical{
    double radius;
    double volume;

    public Shoerical(double radius) {
        this.radius = radius;

        volume = 4/3*radius*radius*radius*Graphical.PI;
        System.out.println("球的半径"+radius);
        System.out.println("球儿的体积"+volume);
    }

}

(3.)静态方法
我们知道如果想使用类中的成员方法,需要先将这个类实例化,但有些时候我们不想或者无法创建对象时,还要调用类中的方法才能够完成业务逻辑,此时就可以使用静态方法.调用类的静态方法时,无需创建类的对象.

public class StaticMethod{
    static public void show(){
    System.out.println("静态方法无需实例化就可以调用");
    }

    public static void main(String[] args){
    StaticMethod.show();

    }

}
System.out.println("---------------");

静态代码块

Eclipse 快捷创建构造方法右键-Source-GenerateConstrutor using Fields…

静态方法(包括静态代码块)不能使用非静态的成员
静态代码块只在类加载的时候执行一次
在类中成员方法之外,用静态static修饰的代码区可以称之为静态代码块.定义一块静态代码块,可以完成类的初始化操作,在类声明时就会运行.

运行顺序: 静态成员–> 静态代码块(只在类加载的时候执行一次)—>非静态成员—>非静态代码块(也就是构造代码块)—>构造方法.成员方法

7.5 类的主方法

主方法是类的入口点,它定义了程序从何处开始;主方法提供了对程序流向的控制,Java编译器通过主方法来执行程序.
主方法是静态的,所以如要直接在主方法中调用其他方法,则该方法必须也是静态的.否则必须创建对象的实例

7.6 对象

7.6.4 对象的比较

public class Compare {
    public static void main(String[] args) {
        String c1 = new String("abc"); // 创建两个String型对象引用
        String c2 = new String("abc");
        String c3 = c1; // 将c1对象引用赋予c3
        // 使用“==”运算符比较c2与c3
        System.out.println("c2==c3的运算结果为：" + (c2 == c3));
        // 使用equals()方法比较c2与c3
        System.out.println("c2.equals(c3)的运算结果为：" + (c2.equals(c3)));
    }
}

上述代码中”==”运算符比较的是两个对象引用的地址值是否相等;
而equals();方法时String类的方法,它用于比较两个对象引用所指的内容是否相等.

第8章包装类

先跳过.

第9章数字处理类

9.1 数字格式化

Java主要对浮点型数据进行数字格式化操作,其中浮点型数据包括double型和float型数据,在Java中使用Java.text.DecimalFormat格式化数字.
在Java中没有格式化的数据遵循以下原则:

如果数据绝对值大于0.001并且小于10000000,Java将以常规小数形式表示.
如果数据绝对值小于0.001并且大于10000000,使用科学计数法表示.

此处缺DecimalFormat类中特殊字符说明的说明图

package LeiHeDuiXiang;

import java.text.DecimalFormat;

public class DecimalFormatSimpleDemo {

    static public void simgleFormat(String pattern,double value) {
        //实例化DecimalFormat对象
        DecimalFormat myFormat = new DecimalFormat(pattern);//需要给DecimalFormat这个对象传参

        System.out.println(value + " "+pattern+" "+myFormat.format(value));
    }

    static public void useApplyPatternMethodFormat(String pattern,double value) {
        DecimalFormat myFormat = new DecimalFormat();//实例化对象,注意这里没有传格式参数
        myFormat.applyPattern(pattern);//调用applyPattern方法设置格式化模板
        System.out.println(value + " "+pattern+" "+myFormat.format(value));

    }


    public static void main(String[] args) {
        simgleFormat("###,###.###",123456.789);
        simgleFormat("00000000.###kg", 123456.789); 
        // 在数字后加上单位, 按照格式模板格式化数字，不存在的位以0显示
        System.out.println("------------------------");
        // 调用静态UseApplyPatternMethodFormat()方法
        useApplyPatternMethodFormat("#.###%", 0.789); // 将数字转换为百分数形式
        // 将小数点后格式化为两位
        useApplyPatternMethodFormat("###.##", 123456.789);
        // 将数字转化为千分数形式
        useApplyPatternMethodFormat("0.00\u2030", 0.789);

    }

}

在DecimalFormat类中除了可以设置格式化模式来格式化数字之外,还可以使用一些特殊方法对数字进行格式化设置.例如:

DecimalFormat myFormat();
myFormat.setGroupingSize(2);
myFormat.setGroupingUsed(false);
//分割
import java.text.DecimalFormat;

public class DecimalMethod {
    public static void main(String[] args) {
        DecimalFormat myFormat = new DecimalFormat();
        myFormat.setGroupingSize(2); // 设置将数字分组为2
        String output = myFormat.format(123456.789);
        System.out.println("将数字以每两个数字分组 " + output);
        myFormat.setGroupingUsed(false); // 设置不允许数字进行分组
        String output2 = myFormat.format(123456.789);
        System.out.println("不允许数字分组 " + output2);
    }
}

9.2 数学运算

跳过有需要回来阅读

qq_39364730

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java笔记(三) 面向对象编程

1.对象属于某一个类,比如麻雀这个对象属于鸟类,不能说类属于某一个对象.7.1 面向对象概述1.对象的创建Java语言中使用new 操作符调用构造方法就可以创建一个对象.//看一个例子//创建一个Test对象Test test = new Test();Test test = new Test("a");先用类声明一个对象,然后让它等于new Test构造方法;而这个构造方法可以有参数,也可以没
复制链接

扫一扫